diff --git a/.github/actions/build_extensions/action.yml b/.github/actions/build_extensions/action.yml index 30296866caa..4357cdf464d 100644 --- a/.github/actions/build_extensions/action.yml +++ b/.github/actions/build_extensions/action.yml @@ -116,17 +116,6 @@ runs: ls -al pwd - - name: Fix for MSVC issue (see e.g. https://github.com/TileDB-Inc/TileDB/pull/4759) - shell: bash - if: inputs.deploy_as == 'windows_amd64' - env: - OVERLAY_TRIPLET_SRC: ${{ github.workspace }}/vcpkg/triplets/community/x64-windows-static-md.cmake - OVERLAY_TRIPLET_DST: ${{ github.workspace }}/overlay_triplets/x64-windows-static-md.cmake - run: | - mkdir overlay_triplets - cp $OVERLAY_TRIPLET_SRC $OVERLAY_TRIPLET_DST - echo "set(VCPKG_PLATFORM_TOOLSET_VERSION "14.39")" >> $OVERLAY_TRIPLET_DST - - name: Set Openssl dir if: inputs.openssl_path != '' shell: bash @@ -155,7 +144,6 @@ runs: GEN: ${{ inputs.ninja == 1 && 'ninja' || '' }} USE_MERGED_VCPKG_MANIFEST: 1 DUCKDB_PLATFORM: ${{ inputs.duckdb_arch }} - VCPKG_OVERLAY_TRIPLETS: "${{ github.workspace }}/overlay_triplets" run: | ls mkdir -p ~/.ssh diff --git a/.github/config/bundled_extensions.cmake b/.github/config/bundled_extensions.cmake index 12bd89a2820..dc9a0931078 100644 --- a/.github/config/bundled_extensions.cmake +++ b/.github/config/bundled_extensions.cmake @@ -25,5 +25,4 @@ duckdb_extension_load(autocomplete) # ## Extensions that are not linked, but we do want to test them as part of the release build # -duckdb_extension_load(sqlsmith DONT_LINK) duckdb_extension_load(tpcds DONT_LINK) diff --git a/.github/config/in_tree_extensions.cmake b/.github/config/in_tree_extensions.cmake index 151d62f8365..6b52aafe6d7 100644 --- a/.github/config/in_tree_extensions.cmake +++ b/.github/config/in_tree_extensions.cmake @@ -12,6 +12,5 @@ duckdb_extension_load(inet) duckdb_extension_load(icu) duckdb_extension_load(json) duckdb_extension_load(parquet) -duckdb_extension_load(sqlsmith) duckdb_extension_load(tpcds) duckdb_extension_load(tpch) diff --git a/.github/config/out_of_tree_extensions.cmake b/.github/config/out_of_tree_extensions.cmake index f9b21d795a6..9d22632ff77 100644 --- a/.github/config/out_of_tree_extensions.cmake +++ b/.github/config/out_of_tree_extensions.cmake @@ -100,12 +100,18 @@ duckdb_extension_load(sqlite_scanner GIT_TAG 50b7870be099186f195bc72bac5e9e11247ee2f9 ) +duckdb_extension_load(sqlsmith + GIT_URL https://github.com/duckdb/duckdb_sqlsmith + GIT_TAG 721460ff1f31ce1dc1e4a9c4a55c0faf0b466dcb + ) + ################# SUBSTRAIT if (NOT WIN32) duckdb_extension_load(substrait LOAD_TESTS DONT_LINK GIT_URL https://github.com/duckdb/substrait GIT_TAG 237931391ebc7e6aee7aa81052fa1411f6c4128e + APPLY_PATCHES ) endif() diff --git a/.github/patches/extensions/substrait/pushdown_semi_anti.patch b/.github/patches/extensions/substrait/pushdown_semi_anti.patch new file mode 100644 index 00000000000..6c4affbd966 --- /dev/null +++ b/.github/patches/extensions/substrait/pushdown_semi_anti.patch @@ -0,0 +1,17 @@ +diff --git a/src/to_substrait.cpp b/src/to_substrait.cpp +index 90f7a67..f252aa7 100644 +--- a/src/to_substrait.cpp ++++ b/src/to_substrait.cpp +@@ -864,7 +864,11 @@ substrait::Rel *DuckDBToSubstrait::TransformComparisonJoin(LogicalOperator &dop) + auto left_col_count = dop.children[0]->types.size(); + if (dop.children[0]->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) { + auto child_join = (LogicalComparisonJoin *)dop.children[0].get(); +- left_col_count = child_join->left_projection_map.size() + child_join->right_projection_map.size(); ++ if (child_join->join_type != JoinType::SEMI && child_join->join_type != JoinType::ANTI) { ++ left_col_count = child_join->left_projection_map.size() + child_join->right_projection_map.size(); ++ } else { ++ left_col_count = child_join->left_projection_map.size(); ++ } + } + sjoin->set_allocated_expression( + CreateConjunction(djoin.conditions, [&](JoinCondition &in) { return TransformJoinCond(in, left_col_count); })); diff --git a/.github/regression/micro_extended.csv b/.github/regression/micro_extended.csv index 7a711a978a8..b87e107bdf7 100644 --- a/.github/regression/micro_extended.csv +++ b/.github/regression/micro_extended.csv @@ -129,6 +129,7 @@ benchmark/micro/join/asof_join.benchmark benchmark/micro/join/asof_join_small_probe.benchmark benchmark/micro/join/blockwise_nl_join.benchmark benchmark/micro/join/delim_join_no_blowup.benchmark +benchmark/micro/join/hashjoin_dups_rhs.benchmark benchmark/micro/join/hashjoin_highcardinality.benchmark benchmark/micro/join/hashjoin_lhsarithmetic.benchmark benchmark/micro/join/iejoin_employees.benchmark diff --git a/.github/workflows/LinuxRelease.yml b/.github/workflows/LinuxRelease.yml index 1ab848d53ff..27579b67ad8 100644 --- a/.github/workflows/LinuxRelease.yml +++ b/.github/workflows/LinuxRelease.yml @@ -167,6 +167,10 @@ jobs: ccache: 1 aarch64_cross_compile: 1 + - name: Checkout (again) + shell: bash + run: git checkout ${{ inputs.git_ref }} + - name: Install unixODBC shell: bash run: | # we need an x86 odbc_config tool to run cmake. fun. @@ -221,6 +225,10 @@ jobs: openssl: 1 ccache: 1 + - name: Checkout (again) + shell: bash + run: git checkout ${{ inputs.git_ref }} + - uses: ./.github/actions/build_extensions with: vcpkg_target_triplet: x64-linux @@ -261,6 +269,10 @@ jobs: aarch64_cross_compile: 1 ccache: 1 + - name: Checkout (again) + shell: bash + run: git checkout ${{ inputs.git_ref }} + - uses: ./.github/actions/build_extensions with: vcpkg_target_triplet: arm64-linux diff --git a/.github/workflows/OnTag.yml b/.github/workflows/OnTag.yml index a88b6eb3df6..b94e7a05bda 100644 --- a/.github/workflows/OnTag.yml +++ b/.github/workflows/OnTag.yml @@ -13,10 +13,10 @@ jobs: uses: ./.github/workflows/TwineUpload.yml secrets: inherit with: - override_git_describe: ${{ inputs.override_git_describe || github.event.release.tag_name }} + override_git_describe: ${{ inputs.override_git_describe || github.ref_name }} staged_upload: uses: ./.github/workflows/StagedUpload.yml secrets: inherit with: - override_git_describe: ${{ inputs.override_git_describe || github.event.release.tag_name }} + override_git_describe: ${{ inputs.override_git_describe || github.ref_name }} diff --git a/.github/workflows/Windows.yml b/.github/workflows/Windows.yml index 664d209a847..c34e53ca8e9 100644 --- a/.github/workflows/Windows.yml +++ b/.github/workflows/Windows.yml @@ -60,6 +60,7 @@ jobs: - uses: actions/checkout@v3 with: fetch-depth: 0 + ref: ${{ inputs.git_ref }} - uses: actions/setup-python@v5 with: @@ -189,6 +190,7 @@ jobs: - uses: actions/checkout@v3 with: fetch-depth: 0 + ref: ${{ inputs.git_ref }} - uses: actions/setup-python@v5 with: @@ -227,6 +229,8 @@ jobs: needs: win-release-64 steps: - uses: actions/checkout@v3 + with: + ref: ${{ inputs.git_ref }} - uses: msys2/setup-msys2@v2 with: msystem: MINGW64 @@ -276,6 +280,7 @@ jobs: - uses: actions/checkout@v3 with: fetch-depth: 0 + ref: ${{ inputs.git_ref }} - uses: actions/setup-python@v5 with: diff --git a/.github/workflows/coverity.yml b/.github/workflows/coverity.yml index bfb79998329..93a37770c52 100644 --- a/.github/workflows/coverity.yml +++ b/.github/workflows/coverity.yml @@ -50,7 +50,6 @@ jobs: BUILD_HTTPFS: 1 BUILD_JSON: 1 BUILD_INET: 1 - BUILD_SQLSMITH: 1 - name: Upload the result run: | diff --git a/.sanitizer-thread-suppressions.txt b/.sanitizer-thread-suppressions.txt index 3ff0939b380..5d3c828970b 100644 --- a/.sanitizer-thread-suppressions.txt +++ b/.sanitizer-thread-suppressions.txt @@ -1,5 +1,6 @@ deadlock:InitializeIndexes race:NextInnerJoin +race:NextRightSemiOrAntiJoin race:duckdb_moodycamel race:duckdb_jemalloc race:AddToEvictionQueue diff --git a/CMakeLists.txt b/CMakeLists.txt index ec66b571939..fa0f5eeb3dc 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -269,7 +269,7 @@ if (OVERRIDE_GIT_DESCRIBE) if (GIT_RESULT) message(WARNING "git is available (at ${GIT_EXECUTABLE}) but has failed to execute 'log -1 --format=%h'. Consider providing explicit GIT_COMMIT_HASH") set(GIT_DESCRIBE "${OVERRIDE_GIT_DESCRIBE}-0-g0123456789") - endif() + endif() else() set(GIT_DESCRIBE "${OVERRIDE_GIT_DESCRIBE}-0-g0123456789") endif() @@ -289,7 +289,7 @@ else() if (GIT_RESULT) message(WARNING "git is available (at ${GIT_EXECUTABLE}) but has failed to execute 'log -1 --format=%h'. Consider providing explicit GIT_COMMIT_HASH or OVERRIDE_GIT_DESCRIBE") set(GIT_COMMIT_HASH "0123456789") - endif() + endif() endif() execute_process( COMMAND ${GIT_EXECUTABLE} describe --tags --long @@ -499,6 +499,37 @@ else() endif() endif() +function(is_number input_string return_var) + if("${input_string}" MATCHES "^[0-9]+$") + set(${return_var} TRUE PARENT_SCOPE) + else() + set(${return_var} FALSE PARENT_SCOPE) + endif() +endfunction() + +set(STANDARD_VECTOR_SIZE "" CACHE STRING "Set a custom STANDARD_VECTOR_SIZE at compile time") +set(BLOCK_ALLOC_SIZE "" CACHE STRING "Set a custom BLOCK_ALLOC_SIZE at compile time") + +if(DEFINED STANDARD_VECTOR_SIZE AND NOT STANDARD_VECTOR_SIZE STREQUAL "") + is_number(${STANDARD_VECTOR_SIZE} is_number_result) + if(is_number_result) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DSTANDARD_VECTOR_SIZE=${STANDARD_VECTOR_SIZE}") + message(STATUS "STANDARD_VECTOR_SIZE is set to ${STANDARD_VECTOR_SIZE}") + else() + message(FATAL_ERROR "STANDARD_VECTOR_SIZE must be a number, not ${STANDARD_VECTOR_SIZE}") + endif() +endif() + +if(DEFINED BLOCK_ALLOC_SIZE AND NOT BLOCK_ALLOC_SIZE STREQUAL "") + is_number(${BLOCK_ALLOC_SIZE} is_number_result) + if(is_number_result) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DDUCKDB_BLOCK_ALLOC_SIZE=${BLOCK_ALLOC_SIZE}") + message(STATUS "BLOCK_ALLOC_SIZE is set to ${BLOCK_ALLOC_SIZE}") + else() + message(FATAL_ERROR "BLOCK_ALLOC_SIZE must be a number, not ${BLOCK_ALLOC_SIZE}") + endif() +endif() + if(CUSTOM_LINKER) set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fuse-ld=${CUSTOM_LINKER}") set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fuse-ld=${CUSTOM_LINKER}") @@ -537,7 +568,7 @@ if(NOT MSVC) endif() else() set(CMAKE_CXX_WINDOWS_FLAGS - "/wd4244 /wd4267 /wd4200 /wd26451 /wd26495 /D_CRT_SECURE_NO_WARNINGS /utf-8") + "/wd4244 /wd4267 /wd4200 /wd26451 /wd26495 /D_CRT_SECURE_NO_WARNINGS /utf-8 /D_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR") if(TREAT_WARNINGS_AS_ERRORS) set(CMAKE_CXX_WINDOWS_FLAGS "${CMAKE_CXX_WINDOWS_FLAGS} /WX") endif() @@ -1260,7 +1291,7 @@ if(BUILD_PYTHON) DUCKDB_BINARY_DIR=${PROJECT_BINARY_DIR} DUCKDB_COMPILE_FLAGS=${ALL_COMPILE_FLAGS} DUCKDB_LIBS="${duckdb_libs}" - ) + ) if(PYTHON_EDITABLE_BUILD) set(PIP_COMMAND ${PIP_COMMAND} python3 -m pip install --editable .) diff --git a/Makefile b/Makefile index 542e17d8dca..2769f00b396 100644 --- a/Makefile +++ b/Makefile @@ -131,9 +131,6 @@ endif ifeq (${STATIC_OPENSSL}, 1) CMAKE_VARS:=${CMAKE_VARS} -DOPENSSL_USE_STATIC_LIBS=1 endif -ifeq (${BUILD_SQLSMITH}, 1) - BUILD_EXTENSIONS:=${BUILD_EXTENSIONS};sqlsmith -endif ifeq (${BUILD_TPCE}, 1) CMAKE_VARS:=${CMAKE_VARS} -DBUILD_TPCE=1 endif @@ -238,6 +235,14 @@ ifdef DEBUG_STACKTRACE CMAKE_VARS:=${CMAKE_VARS} -DDEBUG_STACKTRACE=1 endif +# Optional overrides +ifneq (${STANDARD_VECTOR_SIZE}, ) + CMAKE_VARS:=${CMAKE_VARS} -DSTANDARD_VECTOR_SIZE=${STANDARD_VECTOR_SIZE} +endif +ifneq (${BLOCK_ALLOC_SIZE}, ) + CMAKE_VARS:=${CMAKE_VARS} -DBLOCK_ALLOC_SIZE=${BLOCK_ALLOC_SIZE} +endif + # Enable VCPKG for this build ifneq ("${VCPKG_TOOLCHAIN_PATH}", "") CMAKE_VARS_BUILD:=${CMAKE_VARS_BUILD} -DCMAKE_TOOLCHAIN_FILE='${VCPKG_TOOLCHAIN_PATH}' -DVCPKG_BUILD=1 diff --git a/README.md b/README.md index 008093b62cb..d40913d46ca 100644 --- a/README.md +++ b/README.md @@ -14,12 +14,19 @@

## DuckDB -DuckDB is a high-performance analytical database system. It is designed to be fast, reliable, portable, and easy to use. DuckDB provides a rich SQL dialect, with support far beyond basic SQL. DuckDB supports arbitrary and nested correlated subqueries, window functions, collations, complex types (arrays, structs), and more. For more information on using DuckDB, please refer to the [DuckDB documentation](https://duckdb.org/docs/). + +DuckDB is a high-performance analytical database system. It is designed to be fast, reliable, portable, and easy to use. DuckDB provides a rich SQL dialect, with support far beyond basic SQL. DuckDB supports arbitrary and nested correlated subqueries, window functions, collations, complex types (arrays, structs, maps), and [several extensions designed to make SQL easier to use](https://duckdb.org/docs/guides/sql_features/friendly_sql). + +DuckDB is available as a [standalone CLI application](https://duckdb.org/docs/api/cli/overview) and has clients for [Python](https://duckdb.org/docs/api/python/overview), [R](https://duckdb.org/docs/api/r), [Java](https://duckdb.org/docs/api/java), [Wasm](https://duckdb.org/docs/api/wasm/overview), etc., with deep integrations with packages such as [pandas](https://duckdb.org/docs/guides/python/sql_on_pandas) and [dplyr](https://duckdblabs.github.io/duckplyr/). + +For more information on using DuckDB, please refer to the [DuckDB documentation](https://duckdb.org/docs/). ## Installation -If you want to install and use DuckDB, please see [our website](https://www.duckdb.org) for installation and usage instructions. + +If you want to install DuckDB, please see [our installation page](https://www.duckdb.org/docs/installation) for instructions. ## Data Import + For CSV files and Parquet files, data import is as simple as referencing the file in the FROM clause: ```sql @@ -30,12 +37,15 @@ SELECT * FROM 'myfile.parquet'; Refer to our [Data Import](https://duckdb.org/docs/data/overview) section for more information. ## SQL Reference -The [website](https://duckdb.org/docs/sql/introduction) contains a reference of functions and SQL constructs available in DuckDB. + +The documentation contains a [SQL introduction and reference](https://duckdb.org/docs/sql/introduction). ## Development + For development, DuckDB requires [CMake](https://cmake.org), Python3 and a `C++11` compliant compiler. Run `make` in the root directory to compile the sources. For development, use `make debug` to build a non-optimized debug version. You should run `make unit` and `make allunit` to verify that your version works properly after making changes. To test performance, you can run `BUILD_BENCHMARK=1 BUILD_TPCH=1 make` and then perform several standard benchmarks from the root directory by executing `./build/release/benchmark/benchmark_runner`. The details of benchmarks are in our [Benchmark Guide](benchmark/README.md). Please also refer to our [Build Guide](https://duckdb.org/dev/building) and [Contribution Guide](CONTRIBUTING.md). ## Support + See the [Support Options](https://duckdblabs.com/support/) page. diff --git a/benchmark/benchmark_runner.cpp b/benchmark/benchmark_runner.cpp index 04549b0c3ab..65f5b9af787 100644 --- a/benchmark/benchmark_runner.cpp +++ b/benchmark/benchmark_runner.cpp @@ -59,10 +59,12 @@ atomic is_active; atomic timeout; void sleep_thread(Benchmark *benchmark, BenchmarkRunner *runner, BenchmarkState *state, bool hotrun, - int timeout_duration) { - if (timeout_duration < 0) { + const optional_idx &optional_timeout) { + if (!optional_timeout.IsValid()) { return; } + auto timeout_duration = optional_timeout.GetIndex(); + // timeout is given in seconds // we wait 10ms per iteration, so timeout * 100 gives us the amount of // iterations @@ -130,7 +132,8 @@ void BenchmarkRunner::RunBenchmark(Benchmark *benchmark) { } is_active = true; timeout = false; - std::thread interrupt_thread(sleep_thread, benchmark, this, state.get(), hotrun, benchmark->Timeout()); + std::thread interrupt_thread(sleep_thread, benchmark, this, state.get(), hotrun, + benchmark->Timeout(configuration)); profiler.Start(); benchmark->Run(state.get()); @@ -183,6 +186,8 @@ void print_help() { fprintf(stderr, " --query Prints query of the benchmark\n"); fprintf(stderr, " --root-dir Sets the root directory for where to store temp data and " "look for the 'benchmarks' directory\n"); + fprintf(stderr, " --disable-timeout Disables killing the run after a certain amount of time has " + "passed (30 seconds by default)\n"); fprintf(stderr, " [name_pattern] Run only the benchmark which names match the specified name pattern, " "e.g., DS.* for TPC-DS benchmarks\n"); @@ -253,6 +258,8 @@ void parse_arguments(const int arg_counter, char const *const *arg_values) { } else if (arg == "--query") { // write group of benchmark instance.configuration.meta = BenchmarkMetaType::QUERY; + } else if (arg == "--disable-timeout") { + instance.configuration.timeout_duration = optional_idx(); } else if (StringUtil::StartsWith(arg, "--out=") || StringUtil::StartsWith(arg, "--log=")) { auto splits = StringUtil::Split(arg, '='); if (splits.size() != 2) { diff --git a/benchmark/include/benchmark.hpp b/benchmark/include/benchmark.hpp index b1d8efe660c..ece2dda3d3d 100644 --- a/benchmark/include/benchmark.hpp +++ b/benchmark/include/benchmark.hpp @@ -29,8 +29,6 @@ struct BenchmarkState { //! new benchmarks class Benchmark { constexpr static size_t DEFAULT_NRUNS = 5; - constexpr static size_t DEFAULT_TIMEOUT = 30; - Benchmark(Benchmark &) = delete; public: @@ -87,8 +85,8 @@ class Benchmark { return DEFAULT_NRUNS; } //! The timeout for this benchmark (in seconds) - virtual size_t Timeout() { - return DEFAULT_TIMEOUT; + virtual optional_idx Timeout(const BenchmarkConfiguration &config) { + return config.timeout_duration; } }; diff --git a/benchmark/include/benchmark_configuration.hpp b/benchmark/include/benchmark_configuration.hpp index f8ed43de8d1..02faf77c5ca 100644 --- a/benchmark/include/benchmark_configuration.hpp +++ b/benchmark/include/benchmark_configuration.hpp @@ -12,6 +12,7 @@ #include "duckdb/common/string.hpp" #include "duckdb/common/vector.hpp" #include "duckdb/common/helper.hpp" +#include "duckdb/common/optional_idx.hpp" namespace duckdb { @@ -19,9 +20,14 @@ enum class BenchmarkMetaType { NONE, INFO, QUERY }; enum class BenchmarkProfileInfo { NONE, NORMAL, DETAILED }; struct BenchmarkConfiguration { +public: + constexpr static size_t DEFAULT_TIMEOUT = 30; + +public: string name_pattern {}; BenchmarkMetaType meta = BenchmarkMetaType::NONE; BenchmarkProfileInfo profile_info = BenchmarkProfileInfo::NONE; + optional_idx timeout_duration = optional_idx(DEFAULT_TIMEOUT); }; } // namespace duckdb diff --git a/benchmark/micro/append_mix.cpp b/benchmark/micro/append_mix.cpp index 13446f79499..33801e9f657 100644 --- a/benchmark/micro/append_mix.cpp +++ b/benchmark/micro/append_mix.cpp @@ -62,7 +62,7 @@ using namespace duckdb; string BenchmarkInfo() override { \ return "Append 10M rows to a table using an Appender"; \ } \ - size_t Timeout() override { \ + optional_idx Timeout(const BenchmarkConfiguration &config) override { \ return 600; \ } diff --git a/benchmark/micro/join/hashjoin_dups_rhs.benchmark b/benchmark/micro/join/hashjoin_dups_rhs.benchmark new file mode 100644 index 00000000000..9b9ef9cdc49 --- /dev/null +++ b/benchmark/micro/join/hashjoin_dups_rhs.benchmark @@ -0,0 +1,16 @@ +# name: benchmark/micro/join/hashjoin_dups_rhs.benchmark +# description: Inner hash join using string comparisons with 4x duplicates on the rhs and 4096x duplicates on the lhs +# group: [join] + +name Inner Join (dups on rhs) +group join + +load +create table t1 as select 'verylargestring' || range % 32768 i from range(131072); +create table t2 as select 'verylargestring' || range % 32768 i from range(134217728); + +run +select count(*) from t1 join t2 using (i) + +result I +536870912 \ No newline at end of file diff --git a/data/json/12188.ndjson b/data/json/12188.ndjson new file mode 100644 index 00000000000..2c5b5e06f9b --- /dev/null +++ b/data/json/12188.ndjson @@ -0,0 +1,2 @@ +{"field1": "value1", "field2": {"subfield1": "subvalue1"}} +{"field1": "value2", "field2": {"subfield2": "subvalue2"}} diff --git a/data/parquet-testing/parquet_with_json.parquet b/data/parquet-testing/parquet_with_json.parquet new file mode 100644 index 00000000000..e37dfa0337f Binary files /dev/null and b/data/parquet-testing/parquet_with_json.parquet differ diff --git a/extension/delta/CMakeLists.txt b/extension/delta/CMakeLists.txt new file mode 100644 index 00000000000..c2fa100c362 --- /dev/null +++ b/extension/delta/CMakeLists.txt @@ -0,0 +1,131 @@ +cmake_minimum_required(VERSION 2.8.12) +include(ExternalProject) + +# Core config +set(TARGET_NAME delta) + +set(EXTENSION_NAME ${TARGET_NAME}_extension) +set(LOADABLE_EXTENSION_NAME ${TARGET_NAME}_loadable_extension) + +project(${TARGET_NAME}) + +include_directories(src/include) + +set(EXTENSION_SOURCES src/delta_extension.cpp src/delta_functions.cpp + src/delta_utils.cpp src/functions/delta_scan.cpp) + +# Custom config TODO: figure out if we really need this? +if(APPLE) + set(PLATFORM_LIBS + m + c + System + resolv + "-framework Corefoundation -framework SystemConfiguration -framework Security" + ) +elseif(UNIX) + set(PLATFORM_LIBS m c resolv) +elseif(WIN32) + set(PLATFORM_LIBS ws2_32 userenv advapi32) +else() + message(STATUS "UNKNOWN OS") +endif() + +# Setup delta-kernel-rs dependency +set(KERNEL_NAME delta_kernel) + +# Set default ExternalProject root directory +set_directory_properties(PROPERTIES EP_PREFIX ${CMAKE_BINARY_DIR}/rust) + +# Propagate arch to rust build for CI +set(RUST_PLATFORM_TARGET "") +if("${OS_NAME}" STREQUAL "linux") + if("${OS_ARCH}" STREQUAL "arm64") + set(RUST_PLATFORM_TARGET "aarch64-unknown-linux-gnu") + else() + set(RUST_PLATFORM_TARGET "x86_64-unknown-linux-gnu") + endif() +elseif("${OS_NAME}" STREQUAL "osx") + # TODO: clean up upstream; we are not correctly setting OS_ARCH for cross + # compile + if("${OSX_BUILD_ARCH}" STREQUAL "arm64") + set(RUST_PLATFORM_TARGET "aarch64-apple-darwin") + elseif("${OSX_BUILD_ARCH}" STREQUAL "x86_64") + set(RUST_PLATFORM_TARGET "x86_64-apple-darwin") + elseif("${OS_ARCH}" STREQUAL "arm64") + set(RUST_PLATFORM_TARGET "aarch64-apple-darwin") + else() + set(RUST_PLATFORM_TARGET "x86_64-apple-darwin") + endif() +endif() + +# Add rust_example as a CMake target +ExternalProject_Add( + ${KERNEL_NAME} + GIT_REPOSITORY "https://github.com/delta-incubator/delta-kernel-rs" + GIT_TAG 08f0764a00e89f42136fd478823d28278adc7ee8 + CONFIGURE_COMMAND "" + UPDATE_COMMAND "" + BUILD_IN_SOURCE 1 + # Build debug build + BUILD_COMMAND cargo build --package delta_kernel_ffi --workspace + --all-features --target=${RUST_PLATFORM_TARGET} + # Build release build + COMMAND cargo build --package delta_kernel_ffi --workspace --all-features + --release --target=${RUST_PLATFORM_TARGET} + # Build DATs + COMMAND + cargo build + --manifest-path=${CMAKE_BINARY_DIR}/rust/src/delta_kernel/acceptance/Cargo.toml + BUILD_BYPRODUCTS + "${CMAKE_BINARY_DIR}/rust/src/delta_kernel/target/${RUST_PLATFORM_TARGET}/debug/libdelta_kernel_ffi.a" + BUILD_BYPRODUCTS + "${CMAKE_BINARY_DIR}/rust/src/delta_kernel/target/${RUST_PLATFORM_TARGET}/release/libdelta_kernel_ffi.a" + BUILD_BYPRODUCTS + "${CMAKE_BINARY_DIR}/rust/src/delta_kernel/target/ffi-headers/delta_kernel_ffi.h" + BUILD_BYPRODUCTS + "${CMAKE_BINARY_DIR}/rust/src/delta_kernel/target/ffi-headers/delta_kernel_ffi.hpp" + INSTALL_COMMAND "" + LOG_BUILD ON) + +build_static_extension(${TARGET_NAME} ${EXTENSION_SOURCES}) +build_loadable_extension(${TARGET_NAME} " " ${EXTENSION_SOURCES}) + +include_directories( + ${CMAKE_BINARY_DIR}/rust/src/delta_kernel/target/ffi-headers) +include_directories( + ${CMAKE_BINARY_DIR}/rust/src/delta_kernel/target/ffi-headers) + +# Hides annoying linker warnings +set(CMAKE_OSX_DEPLOYMENT_TARGET + 13.3 + CACHE STRING "Minimum OS X deployment version" FORCE) + +# Add the default client +add_compile_definitions(DEFINE_DEFAULT_ENGINE) + +# Link delta-kernal-rs to static lib +target_link_libraries( + ${EXTENSION_NAME} + debug + "${CMAKE_BINARY_DIR}/rust/src/delta_kernel/target/${RUST_PLATFORM_TARGET}/debug/libdelta_kernel_ffi.a" + optimized + "${CMAKE_BINARY_DIR}/rust/src/delta_kernel/target/${RUST_PLATFORM_TARGET}/release/libdelta_kernel_ffi.a" + ${PLATFORM_LIBS}) +add_dependencies(${EXTENSION_NAME} delta_kernel) + +# Link delta-kernal-rs to dynamic lib +target_link_libraries( + ${LOADABLE_EXTENSION_NAME} + debug + "${CMAKE_BINARY_DIR}/rust/src/delta_kernel/target/${RUST_PLATFORM_TARGET}/debug/libdelta_kernel_ffi.a" + optimized + "${CMAKE_BINARY_DIR}/rust/src/delta_kernel/target/${RUST_PLATFORM_TARGET}/release/libdelta_kernel_ffi.a" + ${PLATFORM_LIBS}) +add_dependencies(${LOADABLE_EXTENSION_NAME} delta_kernel) + +install( + TARGETS ${EXTENSION_NAME} + EXPORT "${DUCKDB_EXPORT_SET}" + LIBRARY DESTINATION "${INSTALL_LIB_DIR}" + ARCHIVE DESTINATION "${INSTALL_LIB_DIR}") diff --git a/extension/delta/Makefile b/extension/delta/Makefile new file mode 100644 index 00000000000..05db9579f22 --- /dev/null +++ b/extension/delta/Makefile @@ -0,0 +1,25 @@ +PROJ_DIR := $(dir $(abspath $(lastword $(MAKEFILE_LIST)))) + +# Configuration of extension +EXT_NAME=deltatable +EXT_CONFIG=${PROJ_DIR}extension_config.cmake + +# Set test paths +test_release: export DELTA_KERNEL_TESTS_PATH=./build/release/rust/src/delta_kernel/kernel/tests/data +test_release: export DAT_PATH=./build/release/rust/src/delta_kernel/acceptance/tests/dat + +test_debug: export DELTA_KERNEL_TESTS_PATH=./build/debug/rust/src/delta_kernel/kernel/tests/data +test_debug: export DAT_PATH=./build/debug/rust/src/delta_kernel/acceptance/tests/dat + +# Include the Makefile from extension-ci-tools +include extension-ci-tools/makefiles/duckdb_extension.Makefile + +reldebug: + mkdir -p build/reldebug && \ + cmake $(GENERATOR) $(BUILD_FLAGS) $(EXT_RELEASE_FLAGS) -DCMAKE_BUILD_TYPE=RelWithDebInfo -S ./duckdb/ -B build/reldebug && \ + cmake --build build/reldebug --config RelWithDebInfo + +# Generate some test data to test with +generate-data: + python3 -m pip install delta-spark duckdb pandas deltalake pyspark delta + python3 scripts/generate_test_data.py diff --git a/extension/delta/README.md b/extension/delta/README.md new file mode 100644 index 00000000000..910c002b7dd --- /dev/null +++ b/extension/delta/README.md @@ -0,0 +1,71 @@ +# DuckDB Delta Extension +This is the experimental DuckDB extension for [Delta](https://delta.io/). It is built using the (also experimental) +[Delta Kernel](https://github.com/delta-incubator/delta-kernel-rs). The extension (currently) offers **read** support for delta +tables, both local and remote. + +# Supported platforms +The supported platforms are: +- `linux_amd64` and `linux_amd64_gcc4` +- `osx_amd64` and `osx_arm64` + +Support for the [other](https://duckdb.org/docs/extensions/working_with_extensions#platforms) DuckDB platforms is +work-in-progress + +# How to use +**NOTE: this extension requires the DuckDB v0.10.3 or higher** + +This extension is distributed as a binary extension. To use it, simply use one of its functions from DuckDB and the extension will be autoloaded: +```SQL +FROM delta_scan('s3://some/delta/table'); +``` + +Note that using DuckDB [Secrets](https://duckdb.org/docs/configuration/secrets_manager.html) for S3 authentication is supported: + +```SQL +CREATE SECRET (TYPE S3, provider credential_chain); +FROM delta_scan('s3://some/delta/table/with/auth'); +``` + +To scan a local table, use the full path prefixes with `file://` +```SQL +FROM delta_scan('file:///some/path/on/local/machine'); +``` + +# Features +While still experimental, many (scanning) features/optimizations are already supported in this extension as it reuses most of DuckDB's +regular parquet scanning logic: +- multithreaded scans and parquet metadata reading +- data skipping/filter pushdown + - skipping row-groups in file (based on parquet metadata) + - skipping complete files (based on delta partition info) +- projection pushdown +- scanning tables with deletion vectors +- all primitive types +- structs +- S3 support with secrets + +More features coming soon! + +# Building +See the [Extension Template](https://github.com/duckdb/extension-template) for generic build instructions + +# Running tests +There are various tests available for the delta extension: +1. Delta Acceptence Test (DAT) based tests in `/test/sql/dat` +2. delta-kernel-rs based tests in `/test/sql/delta_kernel_rs` +3. Generated data based tests in `tests/sql/generated` (generated using [delta-rs](https://delta-io.github.io/delta-rs/), [PySpark](https://spark.apache.org/docs/latest/api/python/index.html), and DuckDB) + +To run the first 2 sets of tests: +```shell +make test_debug +``` +or in release mode +```shell +make test +``` + +To also run the tests on generated data: +```shell +make generate-data +GENERATED_DATA_AVAILABLE=1 make test +``` \ No newline at end of file diff --git a/extension/delta/extension_config.cmake b/extension/delta/extension_config.cmake new file mode 100644 index 00000000000..46e7a27b769 --- /dev/null +++ b/extension/delta/extension_config.cmake @@ -0,0 +1,14 @@ +# This file is included by DuckDB's build system. It specifies which extension to load + +# Extension from this repo +duckdb_extension_load(delta + SOURCE_DIR ${CMAKE_CURRENT_LIST_DIR} + LOAD_TESTS +) + +# Build the httpfs extension to test with s3/http +duckdb_extension_load(httpfs) + +# Build the tpch and tpcds extension for testing/benchmarking +duckdb_extension_load(tpch) +duckdb_extension_load(tpcds) diff --git a/extension/delta/src/delta_extension.cpp b/extension/delta/src/delta_extension.cpp new file mode 100644 index 00000000000..e1f464a6b05 --- /dev/null +++ b/extension/delta/src/delta_extension.cpp @@ -0,0 +1,43 @@ +#define DUCKDB_EXTENSION_MAIN + +#include "delta_extension.hpp" +#include "delta_functions.hpp" + +#include "duckdb.hpp" +#include "duckdb/common/exception.hpp" +#include "duckdb/main/extension_util.hpp" + +namespace duckdb { + +static void LoadInternal(DatabaseInstance &instance) { + // Load functions + for (const auto &function : DeltaFunctions::GetTableFunctions(instance)) { + ExtensionUtil::RegisterFunction(instance, function); + } +} + +void DeltaExtension::Load(DuckDB &db) { + LoadInternal(*db.instance); +} + +std::string DeltaExtension::Name() { + return "delta"; +} + +} // namespace duckdb + +extern "C" { + +DUCKDB_EXTENSION_API void delta_init(duckdb::DatabaseInstance &db) { + duckdb::DuckDB db_wrapper(db); + db_wrapper.LoadExtension(); +} + +DUCKDB_EXTENSION_API const char *delta_version() { + return duckdb::DuckDB::LibraryVersion(); +} +} + +#ifndef DUCKDB_EXTENSION_MAIN +#error DUCKDB_EXTENSION_MAIN not defined +#endif diff --git a/extension/delta/src/delta_functions.cpp b/extension/delta/src/delta_functions.cpp new file mode 100644 index 00000000000..da80b05b4f3 --- /dev/null +++ b/extension/delta/src/delta_functions.cpp @@ -0,0 +1,17 @@ +#include "delta_functions.hpp" + +#include "duckdb.hpp" +#include "duckdb/main/extension_util.hpp" +#include + +namespace duckdb { + +vector DeltaFunctions::GetTableFunctions(DatabaseInstance &instance) { + vector functions; + + functions.push_back(GetDeltaScanFunction(instance)); + + return functions; +} + +}; // namespace duckdb diff --git a/extension/delta/src/delta_utils.cpp b/extension/delta/src/delta_utils.cpp new file mode 100644 index 00000000000..5f909f19f79 --- /dev/null +++ b/extension/delta/src/delta_utils.cpp @@ -0,0 +1,322 @@ +#include "delta_utils.hpp" + +#include "duckdb.hpp" +#include "duckdb/main/extension_util.hpp" +#include + +namespace duckdb { + +unique_ptr SchemaVisitor::VisitSnapshotSchema(ffi::SharedSnapshot *snapshot) { + SchemaVisitor state; + ffi::EngineSchemaVisitor visitor; + + visitor.data = &state; + visitor.make_field_list = (uintptr_t(*)(void *, uintptr_t)) & MakeFieldList; + visitor.visit_struct = (void (*)(void *, uintptr_t, ffi::KernelStringSlice, uintptr_t)) & VisitStruct; + visitor.visit_array = (void (*)(void *, uintptr_t, ffi::KernelStringSlice, bool, uintptr_t)) & VisitArray; + visitor.visit_map = (void (*)(void *, uintptr_t, ffi::KernelStringSlice, bool, uintptr_t)) & VisitMap; + visitor.visit_decimal = (void (*)(void *, uintptr_t, ffi::KernelStringSlice, uint8_t, uint8_t)) & VisitDecimal; + visitor.visit_string = VisitSimpleType(); + visitor.visit_long = VisitSimpleType(); + visitor.visit_integer = VisitSimpleType(); + visitor.visit_short = VisitSimpleType(); + visitor.visit_byte = VisitSimpleType(); + visitor.visit_float = VisitSimpleType(); + visitor.visit_double = VisitSimpleType(); + visitor.visit_boolean = VisitSimpleType(); + visitor.visit_binary = VisitSimpleType(); + visitor.visit_date = VisitSimpleType(); + visitor.visit_timestamp = VisitSimpleType(); + visitor.visit_timestamp_ntz = VisitSimpleType(); + + uintptr_t result = visit_schema(snapshot, &visitor); + return state.TakeFieldList(result); +} + +void SchemaVisitor::VisitDecimal(SchemaVisitor *state, uintptr_t sibling_list_id, ffi::KernelStringSlice name, + uint8_t precision, uint8_t scale) { + state->AppendToList(sibling_list_id, name, LogicalType::DECIMAL(precision, scale)); +} + +uintptr_t SchemaVisitor::MakeFieldList(SchemaVisitor *state, uintptr_t capacity_hint) { + return state->MakeFieldListImpl(capacity_hint); +} + +void SchemaVisitor::VisitStruct(SchemaVisitor *state, uintptr_t sibling_list_id, ffi::KernelStringSlice name, + uintptr_t child_list_id) { + auto children = state->TakeFieldList(child_list_id); + state->AppendToList(sibling_list_id, name, LogicalType::STRUCT(std::move(*children))); +} + +void SchemaVisitor::VisitArray(SchemaVisitor *state, uintptr_t sibling_list_id, ffi::KernelStringSlice name, + bool contains_null, uintptr_t child_list_id) { + auto children = state->TakeFieldList(child_list_id); + + D_ASSERT(children->size() == 1); + state->AppendToList(sibling_list_id, name, LogicalType::LIST(children->front().second)); +} + +void SchemaVisitor::VisitMap(SchemaVisitor *state, uintptr_t sibling_list_id, ffi::KernelStringSlice name, + bool contains_null, uintptr_t child_list_id) { + auto children = state->TakeFieldList(child_list_id); + + D_ASSERT(children->size() == 2); + state->AppendToList(sibling_list_id, name, LogicalType::MAP(LogicalType::STRUCT(std::move(*children)))); +} + +uintptr_t SchemaVisitor::MakeFieldListImpl(uintptr_t capacity_hint) { + uintptr_t id = next_id++; + auto list = make_uniq(); + if (capacity_hint > 0) { + list->reserve(capacity_hint); + } + inflight_lists.emplace(id, std::move(list)); + return id; +} + +void SchemaVisitor::AppendToList(uintptr_t id, ffi::KernelStringSlice name, LogicalType &&child) { + auto it = inflight_lists.find(id); + if (it == inflight_lists.end()) { + // TODO... some error... + throw InternalException("WEIRD SHIT"); + } else { + it->second->emplace_back(std::make_pair(string(name.ptr, name.len), std::move(child))); + } +} + +unique_ptr SchemaVisitor::TakeFieldList(uintptr_t id) { + auto it = inflight_lists.find(id); + if (it == inflight_lists.end()) { + // TODO: Raise some kind of error. + throw InternalException("WEIRD SHIT 2"); + } + auto rval = std::move(it->second); + inflight_lists.erase(it); + return rval; +} + +ffi::EngineError *DuckDBEngineError::AllocateError(ffi::KernelError etype, ffi::KernelStringSlice msg) { + auto error = new DuckDBEngineError; + error->etype = etype; + error->error_message = string(msg.ptr, msg.len); + return error; +} + +string DuckDBEngineError::KernelErrorEnumToString(ffi::KernelError err) { + const char *KERNEL_ERROR_ENUM_STRINGS[] = { + "UnknownError", + "FFIError", + "ArrowError", + "EngineDataTypeError", + "ExtractError", + "GenericError", + "IOErrorError", + "ParquetError", + "ObjectStoreError", + "ObjectStorePathError", + "Reqwest", + "FileNotFoundError", + "MissingColumnError", + "UnexpectedColumnTypeError", + "MissingDataError", + "MissingVersionError", + "DeletionVectorError", + "InvalidUrlError", + "MalformedJsonError", + "MissingMetadataError", + "MissingProtocolError", + "MissingMetadataAndProtocolError", + "ParseError", + "JoinFailureError", + "Utf8Error", + "ParseIntError", + "InvalidColumnMappingMode", + "InvalidTableLocation", + "InvalidDecimalError", + }; + + static_assert(sizeof(KERNEL_ERROR_ENUM_STRINGS) / sizeof(char *) - 1 == (int)ffi::KernelError::InvalidDecimalError, + "KernelErrorEnumStrings mismatched with kernel"); + + if ((int)err < sizeof(KERNEL_ERROR_ENUM_STRINGS) / sizeof(char *)) { + return KERNEL_ERROR_ENUM_STRINGS[(int)err]; + } + + return StringUtil::Format("EnumOutOfRange (enum val out of range: %d)", (int)err); +} + +void DuckDBEngineError::Throw(string from_where) { + // Make copies before calling delete this + auto etype_copy = etype; + auto message_copy = error_message; + + // Consume error by calling delete this (remember this error is created by kernel using AllocateError) + delete this; + throw IOException("Hit DeltaKernel FFI error (from: %s): Hit error: %u (%s) with message (%s)", from_where.c_str(), + etype_copy, KernelErrorEnumToString(etype_copy), message_copy); +} + +ffi::KernelStringSlice KernelUtils::ToDeltaString(const string &str) { + return {str.data(), str.size()}; +} + +string KernelUtils::FromDeltaString(const struct ffi::KernelStringSlice slice) { + return {slice.ptr, slice.len}; +} + +vector KernelUtils::FromDeltaBoolSlice(const struct ffi::KernelBoolSlice slice) { + vector result; + result.assign(slice.ptr, slice.ptr + slice.len); + return result; +} + +PredicateVisitor::PredicateVisitor(const vector &column_names, optional_ptr filters) + : EnginePredicate {.predicate = this, + .visitor = (uintptr_t(*)(void *, ffi::KernelExpressionVisitorState *)) & VisitPredicate} { + if (filters) { + for (auto &filter : filters->filters) { + column_filters[column_names[filter.first]] = filter.second.get(); + } + } +} + +// Template wrapper function that implements get_next for EngineIteratorFromCallable. +template +static auto GetNextFromCallable(Callable *callable) -> decltype(std::declval()()) { + return callable->operator()(); +} + +// Wraps a callable object (e.g. C++11 lambda) as an EngineIterator. +template +ffi::EngineIterator EngineIteratorFromCallable(Callable &callable) { + auto *get_next = &GetNextFromCallable; + return {.data = &callable, .get_next = (const void *(*)(void *))get_next}; +}; + +// Helper function to prevent pushing down filters kernel cant handle +// TODO: remove once kernel handles this properly? +static bool CanHandleFilter(TableFilter *filter) { + switch (filter->filter_type) { + case TableFilterType::CONSTANT_COMPARISON: + return true; + case TableFilterType::CONJUNCTION_AND: { + auto &conjunction = static_cast(*filter); + bool can_handle = true; + for (const auto &child : conjunction.child_filters) { + can_handle = can_handle && CanHandleFilter(child.get()); + } + return can_handle; + } + + default: + return false; + } +} + +// Prunes the list of predicates to ones that we can handle +static unordered_map PrunePredicates(unordered_map predicates) { + unordered_map result; + for (const auto &predicate : predicates) { + if (CanHandleFilter(predicate.second)) { + result[predicate.first] = predicate.second; + } + } + return result; +} + +uintptr_t PredicateVisitor::VisitPredicate(PredicateVisitor *predicate, ffi::KernelExpressionVisitorState *state) { + auto filters = PrunePredicates(predicate->column_filters); + + auto it = filters.begin(); + auto end = filters.end(); + auto get_next = [predicate, state, &it, &end]() -> uintptr_t { + if (it == end) { + return 0; + } + auto &filter = *it++; + return predicate->VisitFilter(filter.first, *filter.second, state); + }; + auto eit = EngineIteratorFromCallable(get_next); + + // TODO: this should be fixed upstream? + try { + return visit_expression_and(state, &eit); + } catch (...) { + return ~0; + } +} + +uintptr_t PredicateVisitor::VisitConstantFilter(const string &col_name, const ConstantFilter &filter, + ffi::KernelExpressionVisitorState *state) { + auto maybe_left = + ffi::visit_expression_column(state, KernelUtils::ToDeltaString(col_name), DuckDBEngineError::AllocateError); + uintptr_t left = KernelUtils::UnpackResult(maybe_left, "VisitConstantFilter failed to visit_expression_column"); + + uintptr_t right = ~0; + auto &value = filter.constant; + switch (value.type().id()) { + case LogicalType::BIGINT: + right = visit_expression_literal_long(state, BigIntValue::Get(value)); + break; + + case LogicalType::VARCHAR: { + // WARNING: C++ lifetime extension rules don't protect calls of the form foo(std::string(...).c_str()) + auto str = StringValue::Get(value); + auto maybe_right = ffi::visit_expression_literal_string(state, KernelUtils::ToDeltaString(col_name), + DuckDBEngineError::AllocateError); + right = KernelUtils::UnpackResult(maybe_right, "VisitConstantFilter failed to visit_expression_literal_string"); + break; + } + + default: + break; // unsupported type + } + + // TODO support other comparison types? + switch (filter.comparison_type) { + case ExpressionType::COMPARE_LESSTHAN: + return visit_expression_lt(state, left, right); + case ExpressionType::COMPARE_LESSTHANOREQUALTO: + return visit_expression_le(state, left, right); + case ExpressionType::COMPARE_GREATERTHAN: + return visit_expression_gt(state, left, right); + case ExpressionType::COMPARE_GREATERTHANOREQUALTO: + return visit_expression_ge(state, left, right); + case ExpressionType::COMPARE_EQUAL: + return visit_expression_eq(state, left, right); + + default: + std::cout << " Unsupported operation: " << (int)filter.comparison_type << std::endl; + return ~0; // Unsupported operation + } +} + +uintptr_t PredicateVisitor::VisitAndFilter(const string &col_name, const ConjunctionAndFilter &filter, + ffi::KernelExpressionVisitorState *state) { + auto it = filter.child_filters.begin(); + auto end = filter.child_filters.end(); + auto get_next = [this, col_name, state, &it, &end]() -> uintptr_t { + if (it == end) { + return 0; + } + auto &child_filter = *it++; + return VisitFilter(col_name, *child_filter, state); + }; + auto eit = EngineIteratorFromCallable(get_next); + return visit_expression_and(state, &eit); +} + +uintptr_t PredicateVisitor::VisitFilter(const string &col_name, const TableFilter &filter, + ffi::KernelExpressionVisitorState *state) { + switch (filter.filter_type) { + case TableFilterType::CONSTANT_COMPARISON: + return VisitConstantFilter(col_name, static_cast(filter), state); + case TableFilterType::CONJUNCTION_AND: + return VisitAndFilter(col_name, static_cast(filter), state); + default: + throw NotImplementedException("Attempted to push down unimplemented filter type: '%s'", + EnumUtil::ToString(filter.filter_type)); + } +} + +}; // namespace duckdb diff --git a/extension/delta/src/functions/delta_scan.cpp b/extension/delta/src/functions/delta_scan.cpp new file mode 100644 index 00000000000..a01bd5f4c42 --- /dev/null +++ b/extension/delta/src/functions/delta_scan.cpp @@ -0,0 +1,628 @@ +#include "duckdb/function/table_function.hpp" + +#include "delta_functions.hpp" +#include "functions/delta_scan.hpp" +#include "duckdb/optimizer/filter_combiner.hpp" +#include "duckdb/planner/operator/logical_get.hpp" +#include "duckdb/main/extension_util.hpp" +#include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp" +#include "duckdb/common/local_file_system.hpp" +#include "duckdb/common/types/data_chunk.hpp" +#include "duckdb/parser/expression/constant_expression.hpp" +#include "duckdb/parser/expression/function_expression.hpp" +#include "duckdb/parser/parsed_expression.hpp" +#include "duckdb/execution/expression_executor.hpp" +#include "duckdb/planner/binder.hpp" +#include "duckdb/main/secret/secret_manager.hpp" + +#include +#include + +namespace duckdb { + +static void *allocate_string(const struct ffi::KernelStringSlice slice) { + return new string(slice.ptr, slice.len); +} + +static void visit_callback(ffi::NullableCvoid engine_context, struct ffi::KernelStringSlice path, int64_t size, + const ffi::DvInfo *dv_info, const struct ffi::CStringMap *partition_values) { + auto context = (DeltaSnapshot *)engine_context; + auto path_string = context->GetPath(); + StringUtil::RTrim(path_string, "/"); + path_string += "/" + KernelUtils::FromDeltaString(path); + + // First we append the file to our resolved files + context->resolved_files.push_back(DeltaSnapshot::ToDuckDBPath(path_string)); + context->metadata.emplace_back(make_uniq()); + + D_ASSERT(context->resolved_files.size() == context->metadata.size()); + + // Initialize the file metadata + context->metadata.back()->delta_snapshot_version = context->version; + context->metadata.back()->file_number = context->resolved_files.size() - 1; + + // Fetch the deletion vector + auto selection_vector_res = + ffi::selection_vector_from_dv(dv_info, context->extern_engine.get(), context->global_state.get()); + auto selection_vector = + KernelUtils::UnpackResult(selection_vector_res, "selection_vector_from_dv for path " + context->GetPath()); + if (selection_vector.ptr) { + context->metadata.back()->selection_vector = selection_vector; + } + + // Lookup all columns for potential hits in the constant map + case_insensitive_map_t constant_map; + for (const auto &col : context->names) { + auto key = KernelUtils::ToDeltaString(col); + auto *partition_val = (string *)ffi::get_from_map(partition_values, key, allocate_string); + if (partition_val) { + constant_map[col] = *partition_val; + delete partition_val; + } + } + context->metadata.back()->partition_map = std::move(constant_map); +} + +static void visit_data(void *engine_context, ffi::EngineData *engine_data, + const struct ffi::KernelBoolSlice selection_vec) { + ffi::visit_scan_data(engine_data, selection_vec, engine_context, visit_callback); +} + +static ffi::EngineBuilder *CreateBuilder(ClientContext &context, const string &path) { + ffi::EngineBuilder *builder; + + // For "regular" paths we early out with the default builder config + if (!StringUtil::StartsWith(path, "s3://")) { + auto interface_builder_res = + ffi::get_engine_builder(KernelUtils::ToDeltaString(path), DuckDBEngineError::AllocateError); + return KernelUtils::UnpackResult(interface_builder_res, "get_engine_interface_builder for path " + path); + } + + auto end_of_container = path.find('/', 5); + + if (end_of_container == string::npos) { + throw IOException("Invalid s3 url passed to delta scan: %s", path); + } + auto bucket = path.substr(5, end_of_container - 5); + auto path_in_bucket = path.substr(end_of_container); + + auto interface_builder_res = + ffi::get_engine_builder(KernelUtils::ToDeltaString(path), DuckDBEngineError::AllocateError); + builder = KernelUtils::UnpackResult(interface_builder_res, "get_engine_interface_builder for path " + path); + + // For S3 paths we need to trim the url, set the container, and fetch a potential secret + auto &secret_manager = SecretManager::Get(context); + auto transaction = CatalogTransaction::GetSystemCatalogTransaction(context); + + auto secret_match = secret_manager.LookupSecret(transaction, path, "s3"); + + // No secret: nothing left to do here! + if (!secret_match.HasMatch()) { + return builder; + } + const auto &kv_secret = dynamic_cast(*secret_match.secret_entry->secret); + + auto key_id = kv_secret.TryGetValue("key_id").ToString(); + auto secret = kv_secret.TryGetValue("secret").ToString(); + auto session_token = kv_secret.TryGetValue("session_token").ToString(); + auto region = kv_secret.TryGetValue("region").ToString(); + + if (key_id.empty() && secret.empty()) { + ffi::set_builder_option(builder, KernelUtils::ToDeltaString("skip_signature"), + KernelUtils::ToDeltaString("true")); + } + + if (!key_id.empty()) { + ffi::set_builder_option(builder, KernelUtils::ToDeltaString("aws_access_key_id"), + KernelUtils::ToDeltaString(key_id)); + } + if (!secret.empty()) { + ffi::set_builder_option(builder, KernelUtils::ToDeltaString("aws_secret_access_key"), + KernelUtils::ToDeltaString(secret)); + } + if (!session_token.empty()) { + ffi::set_builder_option(builder, KernelUtils::ToDeltaString("aws_session_token"), + KernelUtils::ToDeltaString(session_token)); + } + ffi::set_builder_option(builder, KernelUtils::ToDeltaString("aws_region"), KernelUtils::ToDeltaString(region)); + + return builder; +} + +DeltaSnapshot::DeltaSnapshot(ClientContext &context_p, const string &path) + : MultiFileList({ToDeltaPath(path)}, FileGlobOptions::ALLOW_EMPTY), context(context_p) { +} + +string DeltaSnapshot::GetPath() { + return GetPaths()[0]; +} + +string DeltaSnapshot::ToDuckDBPath(const string &raw_path) { + if (StringUtil::StartsWith(raw_path, "file://")) { + return raw_path.substr(7); + } + return raw_path; +} + +string DeltaSnapshot::ToDeltaPath(const string &raw_path) { + string path; + if (StringUtil::StartsWith(raw_path, "./")) { + LocalFileSystem fs; + path = fs.JoinPath(fs.GetWorkingDirectory(), raw_path.substr(2)); + path = "file://" + path; + } else { + path = raw_path; + } + + // Paths always end in a slash (kernel likes it that way for now) + if (path[path.size() - 1] != '/') { + path = path + '/'; + } + + return path; +} + +void DeltaSnapshot::Bind(vector &return_types, vector &names) { + if (!initialized) { + InitializeFiles(); + } + auto schema = SchemaVisitor::VisitSnapshotSchema(snapshot.get()); + for (const auto &field : *schema) { + names.push_back(field.first); + return_types.push_back(field.second); + } + // Store the bound names for resolving the complex filter pushdown later + this->names = names; +} + +string DeltaSnapshot::GetFile(idx_t i) { + if (!initialized) { + InitializeFiles(); + } + // We already have this file + if (i < resolved_files.size()) { + return resolved_files[i]; + } + + if (files_exhausted) { + return ""; + } + + while (i >= resolved_files.size()) { + auto have_scan_data_res = ffi::kernel_scan_data_next(scan_data_iterator.get(), this, visit_data); + + auto have_scan_data = TryUnpackKernelResult(have_scan_data_res); + + // kernel has indicated that we have no more data to scan + if (!have_scan_data) { + files_exhausted = true; + return ""; + } + } + + // The kernel scan visitor should have resolved a file OR returned + if (i >= resolved_files.size()) { + throw IOException("Delta Kernel seems to have failed to resolve a new file"); + } + + return resolved_files[i]; +} + +void DeltaSnapshot::InitializeFiles() { + auto path_slice = KernelUtils::ToDeltaString(paths[0]); + + // Register engine + auto interface_builder = CreateBuilder(context, paths[0]); + extern_engine = TryUnpackKernelResult(ffi::builder_build(interface_builder)); + + // Initialize Snapshot + snapshot = TryUnpackKernelResult(ffi::snapshot(path_slice, extern_engine.get())); + + // Create Scan + PredicateVisitor visitor(names, &table_filters); + scan = TryUnpackKernelResult(ffi::scan(snapshot.get(), extern_engine.get(), &visitor)); + + // Create GlobalState + global_state = ffi::get_global_scan_state(scan.get()); + + // Set version + this->version = ffi::version(snapshot.get()); + + // Create scan data iterator + scan_data_iterator = TryUnpackKernelResult(ffi::kernel_scan_data_init(extern_engine.get(), scan.get())); + + initialized = true; +} + +unique_ptr DeltaSnapshot::ComplexFilterPushdown(ClientContext &context, + const MultiFileReaderOptions &options, LogicalGet &get, + vector> &filters) { + FilterCombiner combiner(context); + for (const auto &filter : filters) { + combiner.AddFilter(filter->Copy()); + } + auto filterstmp = combiner.GenerateTableScanFilters(get.column_ids); + + // TODO: can/should we figure out if this filtered anything? + auto filtered_list = make_uniq(context, paths[0]); + filtered_list->table_filters = std::move(filterstmp); + filtered_list->names = names; + + return std::move(filtered_list); +} + +vector DeltaSnapshot::GetAllFiles() { + idx_t i = resolved_files.size(); + // TODO: this can probably be improved + while (!GetFile(i).empty()) { + i++; + } + return resolved_files; +} + +FileExpandResult DeltaSnapshot::GetExpandResult() { + // GetFile(1) will ensure at least the first 2 files are expanded if they are available + GetFile(1); + + if (resolved_files.size() > 1) { + return FileExpandResult::MULTIPLE_FILES; + } else if (resolved_files.size() == 1) { + return FileExpandResult::SINGLE_FILE; + } + + return FileExpandResult::NO_FILES; +} + +idx_t DeltaSnapshot::GetTotalFileCount() { + // TODO: this can probably be improved + idx_t i = resolved_files.size(); + while (!GetFile(i).empty()) { + i++; + } + return resolved_files.size(); +} + +unique_ptr DeltaMultiFileReader::CreateInstance() { + return std::move(make_uniq()); +} + +bool DeltaMultiFileReader::Bind(MultiFileReaderOptions &options, MultiFileList &files, + vector &return_types, vector &names, + MultiFileReaderBindData &bind_data) { + auto &delta_snapshot = dynamic_cast(files); + + delta_snapshot.Bind(return_types, names); + + // We need to parse this option + bool file_row_number_enabled = options.custom_options.find("file_row_number") != options.custom_options.end(); + if (file_row_number_enabled) { + bind_data.file_row_number_idx = names.size(); + return_types.emplace_back(LogicalType::BIGINT); + names.emplace_back("file_row_number"); + } else { + // TODO: this is a bogus ID? Change for flag indicating it should be enabled? + bind_data.file_row_number_idx = names.size(); + } + + return true; +}; + +void DeltaMultiFileReader::BindOptions(MultiFileReaderOptions &options, MultiFileList &files, + vector &return_types, vector &names, + MultiFileReaderBindData &bind_data) { + + // Disable all other multifilereader options + options.auto_detect_hive_partitioning = false; + options.hive_partitioning = false; + options.union_by_name = false; + + MultiFileReader::BindOptions(options, files, return_types, names, bind_data); + + auto demo_gen_col_opt = options.custom_options.find("delta_file_number"); + if (demo_gen_col_opt != options.custom_options.end()) { + if (demo_gen_col_opt->second.GetValue()) { + names.push_back("delta_file_number"); + return_types.push_back(LogicalType::UBIGINT); + } + } +} + +void DeltaMultiFileReader::FinalizeBind(const MultiFileReaderOptions &file_options, + const MultiFileReaderBindData &options, const string &filename, + const vector &local_names, const vector &global_types, + const vector &global_names, const vector &global_column_ids, + MultiFileReaderData &reader_data, ClientContext &context, + optional_ptr global_state) { + MultiFileReader::FinalizeBind(file_options, options, filename, local_names, global_types, global_names, + global_column_ids, reader_data, context, global_state); + + // Handle custom delta option set in MultiFileReaderOptions::custom_options + auto file_number_opt = file_options.custom_options.find("delta_file_number"); + if (file_number_opt != file_options.custom_options.end()) { + if (file_number_opt->second.GetValue()) { + D_ASSERT(global_state); + auto &delta_global_state = global_state->Cast(); + D_ASSERT(delta_global_state.delta_file_number_idx != DConstants::INVALID_INDEX); + + // We add the constant column for the delta_file_number option + // NOTE: we add a placeholder here, to demonstrate how we can also populate extra columns in the + // FinalizeChunk + reader_data.constant_map.emplace_back(delta_global_state.delta_file_number_idx, Value::UBIGINT(0)); + } + } + + // Get the metadata for this file + D_ASSERT(global_state->file_list); + const auto &snapshot = dynamic_cast(*global_state->file_list); + auto &file_metadata = snapshot.metadata[reader_data.file_list_idx.GetIndex()]; + + if (!file_metadata->partition_map.empty()) { + for (idx_t i = 0; i < global_column_ids.size(); i++) { + column_t col_id = global_column_ids[i]; + auto col_partition_entry = file_metadata->partition_map.find(global_names[col_id]); + if (col_partition_entry != file_metadata->partition_map.end()) { + // Todo: use https://github.com/delta-io/delta/blob/master/PROTOCOL.md#partition-value-serialization + auto maybe_value = Value(col_partition_entry->second).DefaultCastAs(global_types[i]); + reader_data.constant_map.emplace_back(i, maybe_value); + } + } + } +} + +unique_ptr DeltaMultiFileReader::CreateFileList(ClientContext &context, const vector &paths, + FileGlobOptions options) { + if (paths.size() != 1) { + throw BinderException("'delta_scan' only supports single path as input"); + } + + return make_uniq(context, paths[0]); +} + +// Generate the correct Selection Vector Based on the Raw delta KernelBoolSlice dv and the row_id_column +// TODO: this probably is slower than needed (we can do with less branches in the for loop for most cases) +static SelectionVector DuckSVFromDeltaSV(const ffi::KernelBoolSlice &dv, Vector row_id_column, idx_t count, + idx_t &select_count) { + D_ASSERT(row_id_column.GetType() == LogicalType::BIGINT); + + UnifiedVectorFormat data; + row_id_column.ToUnifiedFormat(count, data); + auto row_ids = UnifiedVectorFormat::GetData(data); + + SelectionVector result {count}; + idx_t current_select = 0; + for (idx_t i = 0; i < count; i++) { + auto row_id = row_ids[data.sel->get_index(i)]; + + // TODO: why are deletion vectors not spanning whole data? + if (row_id >= dv.len || dv.ptr[row_id]) { + result.data()[current_select] = i; + current_select++; + } + } + + select_count = current_select; + + return result; +} + +// Parses the columns that are used by the delta extension into +void DeltaMultiFileReaderGlobalState::SetColumnIdx(const string &column, idx_t idx) { + if (column == "file_row_number") { + file_row_number_idx = idx; + return; + } else if (column == "delta_file_number") { + delta_file_number_idx = idx; + return; + } + throw IOException("Unknown column '%s' found as required by the DeltaMultiFileReader"); +} + +unique_ptr DeltaMultiFileReader::InitializeGlobalState( + duckdb::ClientContext &context, const duckdb::MultiFileReaderOptions &file_options, + const duckdb::MultiFileReaderBindData &bind_data, const duckdb::MultiFileList &file_list, + const vector &global_types, const vector &global_names, + const vector &global_column_ids) { + vector extra_columns; + vector> mapped_columns; + + // Create a map of the columns that are in the projection + case_insensitive_map_t selected_columns; + for (idx_t i = 0; i < global_column_ids.size(); i++) { + auto global_id = global_column_ids[i]; + if (IsRowIdColumnId(global_id)) { + continue; + } + + auto &global_name = global_names[global_id]; + selected_columns.insert({global_name, i}); + } + + // TODO: only add file_row_number column if there are deletes + case_insensitive_map_t columns_to_map = { + {"file_row_number", LogicalType::BIGINT}, + }; + + // Add the delta_file_number column to the columns to map + auto demo_gen_col_opt = file_options.custom_options.find("delta_file_number"); + if (demo_gen_col_opt != file_options.custom_options.end()) { + if (demo_gen_col_opt->second.GetValue()) { + columns_to_map.insert({"delta_file_number", LogicalType::UBIGINT}); + } + } + + // Map every column to either a column in the projection, or add it to the extra columns if it doesn't exist + idx_t col_offset = 0; + for (const auto &required_column : columns_to_map) { + // First check if the column is in the projection + auto res = selected_columns.find(required_column.first); + if (res != selected_columns.end()) { + // The column is in the projection, no special handling is required; we simply store the index + mapped_columns.push_back({required_column.first, res->second}); + continue; + } + + // The column is NOT in the projection: it needs to be added as an extra_column + + // Calculate the index of the added column (extra columns are added after all other columns) + idx_t current_col_idx = global_column_ids.size() + col_offset++; + + // Add column to the map, to ensure the MultiFileReader can find it when processing the Chunk + mapped_columns.push_back({required_column.first, current_col_idx}); + + // Ensure the result DataChunk has a vector of the correct type to store this column + extra_columns.push_back(required_column.second); + } + + auto res = make_uniq(extra_columns, &file_list); + + // Parse all the mapped columns into the DeltaMultiFileReaderGlobalState for easy use; + for (const auto &mapped_column : mapped_columns) { + res->SetColumnIdx(mapped_column.first, mapped_column.second); + } + + return std::move(res); +} + +void DeltaMultiFileReader::CreateNameMapping(const string &file_name, const vector &local_types, + const vector &local_names, const vector &global_types, + const vector &global_names, + const vector &global_column_ids, + MultiFileReaderData &reader_data, const string &initial_file, + optional_ptr global_state) { + // First call the base implementation to do most mapping + MultiFileReader::CreateNameMapping(file_name, local_types, local_names, global_types, global_names, + global_column_ids, reader_data, initial_file, global_state); + + // Then we handle delta specific mapping + D_ASSERT(global_state); + auto &delta_global_state = global_state->Cast(); + + // Check if the file_row_number column is an "extra_column" which is not part of the projection + if (delta_global_state.file_row_number_idx >= global_column_ids.size()) { + D_ASSERT(delta_global_state.file_row_number_idx != DConstants::INVALID_INDEX); + + // Build the name map + case_insensitive_map_t name_map; + for (idx_t col_idx = 0; col_idx < local_names.size(); col_idx++) { + name_map[local_names[col_idx]] = col_idx; + } + + // Lookup the required column in the local map + auto entry = name_map.find("file_row_number"); + if (entry == name_map.end()) { + throw IOException("Failed to find the file_row_number column"); + } + + // Register the column to be scanned from this file + reader_data.column_ids.push_back(entry->second); + reader_data.column_mapping.push_back(delta_global_state.file_row_number_idx); + } + + // This may have changed: update it + reader_data.empty_columns = reader_data.column_ids.empty(); +} + +void DeltaMultiFileReader::FinalizeChunk(ClientContext &context, const MultiFileReaderBindData &bind_data, + const MultiFileReaderData &reader_data, DataChunk &chunk, + optional_ptr global_state) { + // Base class finalization first + MultiFileReader::FinalizeChunk(context, bind_data, reader_data, chunk, global_state); + + D_ASSERT(global_state); + auto &delta_global_state = global_state->Cast(); + D_ASSERT(delta_global_state.file_list); + + // Get the metadata for this file + const auto &snapshot = dynamic_cast(*global_state->file_list); + auto &metadata = snapshot.metadata[reader_data.file_list_idx.GetIndex()]; + + if (metadata->selection_vector.ptr && chunk.size() != 0) { + D_ASSERT(delta_global_state.file_row_number_idx != DConstants::INVALID_INDEX); + auto &file_row_number_column = chunk.data[delta_global_state.file_row_number_idx]; + + // Construct the selection vector using the file_row_number column and the raw selection vector from delta + idx_t select_count; + auto sv = DuckSVFromDeltaSV(metadata->selection_vector, file_row_number_column, chunk.size(), select_count); + chunk.Slice(sv, select_count); + } + + // Note: this demo function shows how we can use DuckDB's Binder create expression-based generated columns + if (delta_global_state.delta_file_number_idx != DConstants::INVALID_INDEX) { + //! Create Dummy expression (0 + file_number) + vector> child_expr; + child_expr.push_back(make_uniq(Value::UBIGINT(0))); + child_expr.push_back(make_uniq(Value::UBIGINT(7))); + unique_ptr expr = + make_uniq("+", std::move(child_expr), nullptr, nullptr, false, true); + + //! s dummy expression + auto binder = Binder::CreateBinder(context); + ExpressionBinder expr_binder(*binder, context); + auto bound_expr = expr_binder.Bind(expr, nullptr); + + //! Execute dummy expression into result column + ExpressionExecutor expr_executor(context); + expr_executor.AddExpression(*bound_expr); + + //! Execute the expression directly into the output Chunk + expr_executor.ExecuteExpression(chunk.data[delta_global_state.delta_file_number_idx]); + } +}; + +bool DeltaMultiFileReader::ParseOption(const string &key, const Value &val, MultiFileReaderOptions &options, + ClientContext &context) { + auto loption = StringUtil::Lower(key); + + if (loption == "delta_file_number") { + options.custom_options[loption] = val; + return true; + } + + // We need to capture this one to know whether to emit + if (loption == "file_row_number") { + options.custom_options[loption] = val; + return true; + } + + return MultiFileReader::ParseOption(key, val, options, context); +} +// +// DeltaMultiFileReaderBindData::DeltaMultiFileReaderBindData(DeltaSnapshot & delta_snapshot): +// current_snapshot(delta_snapshot){ +// +//} + +TableFunctionSet DeltaFunctions::GetDeltaScanFunction(DatabaseInstance &instance) { + // The delta_scan function is constructed by grabbing the parquet scan from the Catalog, then injecting the + // DeltaMultiFileReader into it to create a Delta-based multi file read + + auto &parquet_scan = ExtensionUtil::GetTableFunction(instance, "parquet_scan"); + auto parquet_scan_copy = parquet_scan.functions; + + for (auto &function : parquet_scan_copy.functions) { + // Register the MultiFileReader as the driver for reads + function.get_multi_file_reader = DeltaMultiFileReader::CreateInstance; + + // Unset all of these: they are either broken, very inefficient. + // TODO: implement/fix these + function.serialize = nullptr; + function.deserialize = nullptr; + function.statistics = nullptr; + function.table_scan_progress = nullptr; + function.cardinality = nullptr; + function.get_bind_info = nullptr; + + // Schema param is just confusing here + function.named_parameters.erase("schema"); + + // Demonstration of a generated column based on information from DeltaSnapshot + function.named_parameters["delta_file_number"] = LogicalType::BOOLEAN; + + function.name = "delta_scan"; + } + + parquet_scan_copy.name = "delta_scan"; + return parquet_scan_copy; +} + +} // namespace duckdb diff --git a/extension/delta/src/include/delta_extension.hpp b/extension/delta/src/include/delta_extension.hpp new file mode 100644 index 00000000000..d6b13f236b8 --- /dev/null +++ b/extension/delta/src/include/delta_extension.hpp @@ -0,0 +1,13 @@ +#pragma once + +#include "duckdb.hpp" + +namespace duckdb { + +class DeltaExtension : public Extension { +public: + void Load(DuckDB &db) override; + std::string Name() override; +}; + +} // namespace duckdb diff --git a/extension/delta/src/include/delta_functions.hpp b/extension/delta/src/include/delta_functions.hpp new file mode 100644 index 00000000000..4f819cbfd63 --- /dev/null +++ b/extension/delta/src/include/delta_functions.hpp @@ -0,0 +1,22 @@ +//===----------------------------------------------------------------------===// +// DuckDB +// +// delta_functions.hpp +// +// +//===----------------------------------------------------------------------===// + +#pragma once + +#include "duckdb/parser/parsed_data/create_table_function_info.hpp" + +namespace duckdb { + +class DeltaFunctions { +public: + static vector GetTableFunctions(DatabaseInstance &instance); + +private: + static TableFunctionSet GetDeltaScanFunction(DatabaseInstance &instance); +}; +} // namespace duckdb diff --git a/extension/delta/src/include/delta_utils.hpp b/extension/delta/src/include/delta_utils.hpp new file mode 100644 index 00000000000..4b478c998f6 --- /dev/null +++ b/extension/delta/src/include/delta_utils.hpp @@ -0,0 +1,155 @@ +#pragma once + +#include "delta_kernel_ffi.hpp" +#include "duckdb/planner/filter/constant_filter.hpp" +#include "duckdb/planner/filter/conjunction_filter.hpp" +#include "duckdb/common/enum_util.hpp" +#include + +// TODO: clean up this file as we go + +namespace duckdb { + +// SchemaVisitor is used to parse the schema of a Delta table from the Kernel +class SchemaVisitor { +public: + using FieldList = child_list_t; + + static unique_ptr VisitSnapshotSchema(ffi::SharedSnapshot *snapshot); + +private: + unordered_map> inflight_lists; + uintptr_t next_id = 1; + + typedef void(SimpleTypeVisitorFunction)(void *, uintptr_t, ffi::KernelStringSlice); + + template + static SimpleTypeVisitorFunction *VisitSimpleType() { + return (SimpleTypeVisitorFunction *)&VisitSimpleTypeImpl; + } + template + static void VisitSimpleTypeImpl(SchemaVisitor *state, uintptr_t sibling_list_id, ffi::KernelStringSlice name) { + state->AppendToList(sibling_list_id, name, TypeId); + } + + static void VisitDecimal(SchemaVisitor *state, uintptr_t sibling_list_id, ffi::KernelStringSlice name, + uint8_t precision, uint8_t scale); + static uintptr_t MakeFieldList(SchemaVisitor *state, uintptr_t capacity_hint); + static void VisitStruct(SchemaVisitor *state, uintptr_t sibling_list_id, ffi::KernelStringSlice name, + uintptr_t child_list_id); + static void VisitArray(SchemaVisitor *state, uintptr_t sibling_list_id, ffi::KernelStringSlice name, + bool contains_null, uintptr_t child_list_id); + static void VisitMap(SchemaVisitor *state, uintptr_t sibling_list_id, ffi::KernelStringSlice name, + bool contains_null, uintptr_t child_list_id); + + uintptr_t MakeFieldListImpl(uintptr_t capacity_hint); + void AppendToList(uintptr_t id, ffi::KernelStringSlice name, LogicalType &&child); + unique_ptr TakeFieldList(uintptr_t id); +}; + +// Allocator for errors that the kernel might throw +struct DuckDBEngineError : ffi::EngineError { + // Allocate a DuckDBEngineError, function ptr passed to kernel for error allocation + static ffi::EngineError *AllocateError(ffi::KernelError etype, ffi::KernelStringSlice msg); + // Convert a kernel error enum to a string + static string KernelErrorEnumToString(ffi::KernelError err); + + // Throw the error as an IOException + [[noreturn]] void Throw(string from_info); + + // The error message from Kernel + string error_message; +}; + +// RAII wrapper that returns ownership of a kernel pointer to kernel when it goes out of +// scope. Similar to std::unique_ptr. but does not define operator->() and does not require the +// kernel type to be complete. +template +struct UniqueKernelPointer { + UniqueKernelPointer() : ptr(nullptr), free(nullptr) { + } + + // Takes ownership of a pointer with associated deleter. + UniqueKernelPointer(KernelType *ptr, void (*free)(KernelType *)) : ptr(ptr), free(free) { + } + + // movable but not copyable + UniqueKernelPointer(UniqueKernelPointer &&other) : ptr(other.ptr) { + other.ptr = nullptr; + } + UniqueKernelPointer &operator=(UniqueKernelPointer &&other) { + std::swap(ptr, other.ptr); + std::swap(free, other.free); + return *this; + } + UniqueKernelPointer(const UniqueKernelPointer &) = delete; + UniqueKernelPointer &operator=(const UniqueKernelPointer &) = delete; + + ~UniqueKernelPointer() { + if (ptr && free) { + free(ptr); + } + } + + KernelType *get() const { + return ptr; + } + +private: + KernelType *ptr; + void (*free)(KernelType *) = nullptr; +}; + +// Syntactic sugar around the different kernel types +template +struct TemplatedUniqueKernelPointer : public UniqueKernelPointer { + TemplatedUniqueKernelPointer() : UniqueKernelPointer() {}; + TemplatedUniqueKernelPointer(KernelType *ptr) : UniqueKernelPointer(ptr, DeleteFunction) {}; +}; + +typedef TemplatedUniqueKernelPointer KernelSnapshot; +typedef TemplatedUniqueKernelPointer KernelExternEngine; +typedef TemplatedUniqueKernelPointer KernelScan; +typedef TemplatedUniqueKernelPointer KernelGlobalScanState; +typedef TemplatedUniqueKernelPointer KernelScanDataIterator; + +struct KernelUtils { + static ffi::KernelStringSlice ToDeltaString(const string &str); + static string FromDeltaString(const struct ffi::KernelStringSlice slice); + static vector FromDeltaBoolSlice(const struct ffi::KernelBoolSlice slice); + + // TODO: all kernel results need to be unpacked, not doing so will result in an error. This should be cleaned up + template + static T UnpackResult(ffi::ExternResult result, const string &from_where) { + if (result.tag == ffi::ExternResult::Tag::Err) { + if (result.err._0) { + auto error_cast = static_cast(result.err._0); + error_cast->Throw(from_where); + } else { + throw IOException("Hit DeltaKernel FFI error (from: %s): Hit error, but error was nullptr", + from_where.c_str()); + } + } else if (result.tag == ffi::ExternResult::Tag::Ok) { + return result.ok._0; + } + throw IOException("Invalid error ExternResult tag found!"); + } +}; + +class PredicateVisitor : public ffi::EnginePredicate { +public: + PredicateVisitor(const vector &column_names, optional_ptr filters); + +private: + unordered_map column_filters; + + static uintptr_t VisitPredicate(PredicateVisitor *predicate, ffi::KernelExpressionVisitorState *state); + + uintptr_t VisitConstantFilter(const string &col_name, const ConstantFilter &filter, + ffi::KernelExpressionVisitorState *state); + uintptr_t VisitAndFilter(const string &col_name, const ConjunctionAndFilter &filter, + ffi::KernelExpressionVisitorState *state); + uintptr_t VisitFilter(const string &col_name, const TableFilter &filter, ffi::KernelExpressionVisitorState *state); +}; + +} // namespace duckdb diff --git a/extension/delta/src/include/functions/delta_scan.hpp b/extension/delta/src/include/functions/delta_scan.hpp new file mode 100644 index 00000000000..32d681fa3db --- /dev/null +++ b/extension/delta/src/include/functions/delta_scan.hpp @@ -0,0 +1,146 @@ +//===----------------------------------------------------------------------===// +// DuckDB +// +// functions/delta_scan.hpp +// +// +//===----------------------------------------------------------------------===// + +#pragma once + +#include "delta_utils.hpp" +#include "duckdb/common/multi_file_reader.hpp" + +namespace duckdb { + +struct DeltaFileMetaData { + DeltaFileMetaData() {}; + + // No copying pls + DeltaFileMetaData(const DeltaFileMetaData &) = delete; + DeltaFileMetaData &operator=(const DeltaFileMetaData &) = delete; + + ~DeltaFileMetaData() { + if (selection_vector.ptr) { + ffi::drop_bool_slice(selection_vector); + } + } + + idx_t delta_snapshot_version = DConstants::INVALID_INDEX; + idx_t file_number = DConstants::INVALID_INDEX; + ffi::KernelBoolSlice selection_vector = {nullptr, 0}; + case_insensitive_map_t partition_map; +}; + +//! The DeltaSnapshot implements the MultiFileList API to allow injecting it into the regular DuckDB parquet scan +struct DeltaSnapshot : public MultiFileList { + DeltaSnapshot(ClientContext &context, const string &path); + string GetPath(); + static string ToDuckDBPath(const string &raw_path); + static string ToDeltaPath(const string &raw_path); + + //! MultiFileList API +public: + void Bind(vector &return_types, vector &names); + unique_ptr ComplexFilterPushdown(ClientContext &context, const MultiFileReaderOptions &options, + LogicalGet &get, vector> &filters) override; + vector GetAllFiles() override; + FileExpandResult GetExpandResult() override; + idx_t GetTotalFileCount() override; + +protected: + //! Get the i-th expanded file + string GetFile(idx_t i) override; + +protected: + // TODO: How to guarantee we only call this after the filter pushdown? + void InitializeFiles(); + + template + T TryUnpackKernelResult(ffi::ExternResult result) { + return KernelUtils::UnpackResult( + result, StringUtil::Format("While trying to read from delta table: '%s'", paths[0])); + } + + // TODO: change back to protected +public: + idx_t version; + + //! Delta Kernel Structures + KernelSnapshot snapshot; + KernelExternEngine extern_engine; + KernelScan scan; + KernelGlobalScanState global_state; + KernelScanDataIterator scan_data_iterator; + + //! Names + vector names; + + //! Metadata map for files + vector> metadata; + + //! Current file list resolution state + bool initialized = false; + bool files_exhausted = false; + vector resolved_files; + TableFilterSet table_filters; + + ClientContext &context; +}; + +struct DeltaMultiFileReaderGlobalState : public MultiFileReaderGlobalState { + DeltaMultiFileReaderGlobalState(vector extra_columns_p, optional_ptr file_list_p) + : MultiFileReaderGlobalState(extra_columns_p, file_list_p) { + } + //! The idx of the file number column in the result chunk + idx_t delta_file_number_idx = DConstants::INVALID_INDEX; + //! The idx of the file_row_number column in the result chunk + idx_t file_row_number_idx = DConstants::INVALID_INDEX; + + void SetColumnIdx(const string &column, idx_t idx); +}; + +struct DeltaMultiFileReader : public MultiFileReader { + static unique_ptr CreateInstance(); + //! Return a DeltaSnapshot + unique_ptr CreateFileList(ClientContext &context, const vector &paths, + FileGlobOptions options) override; + + //! Override the regular parquet bind using the MultiFileReader Bind. The bind from these are what DuckDB's file + //! readers will try read + bool Bind(MultiFileReaderOptions &options, MultiFileList &files, vector &return_types, + vector &names, MultiFileReaderBindData &bind_data) override; + + //! Override the Options bind + void BindOptions(MultiFileReaderOptions &options, MultiFileList &files, vector &return_types, + vector &names, MultiFileReaderBindData &bind_data) override; + + void CreateNameMapping(const string &file_name, const vector &local_types, + const vector &local_names, const vector &global_types, + const vector &global_names, const vector &global_column_ids, + MultiFileReaderData &reader_data, const string &initial_file, + optional_ptr global_state) override; + + unique_ptr + InitializeGlobalState(ClientContext &context, const MultiFileReaderOptions &file_options, + const MultiFileReaderBindData &bind_data, const MultiFileList &file_list, + const vector &global_types, const vector &global_names, + const vector &global_column_ids) override; + + void FinalizeBind(const MultiFileReaderOptions &file_options, const MultiFileReaderBindData &options, + const string &filename, const vector &local_names, + const vector &global_types, const vector &global_names, + const vector &global_column_ids, MultiFileReaderData &reader_data, + ClientContext &context, optional_ptr global_state) override; + + //! Override the FinalizeChunk method + void FinalizeChunk(ClientContext &context, const MultiFileReaderBindData &bind_data, + const MultiFileReaderData &reader_data, DataChunk &chunk, + optional_ptr global_state) override; + + //! Override the ParseOption call to parse delta_scan specific options + bool ParseOption(const string &key, const Value &val, MultiFileReaderOptions &options, + ClientContext &context) override; +}; + +} // namespace duckdb diff --git a/extension/delta/vcpkg.json b/extension/delta/vcpkg.json new file mode 100644 index 00000000000..85936bf44cc --- /dev/null +++ b/extension/delta/vcpkg.json @@ -0,0 +1,5 @@ +{ + "dependencies": [ + "openssl" + ] +} \ No newline at end of file diff --git a/extension/fts/fts_indexing.cpp b/extension/fts/fts_indexing.cpp index 0673dcef0bd..c098f194901 100644 --- a/extension/fts/fts_indexing.cpp +++ b/extension/fts/fts_indexing.cpp @@ -191,7 +191,7 @@ static string IndexingScript(ClientContext &context, QualifiedName &qname, const term_tf.termid, tf, df, - (log(((SELECT num_docs FROM %fts_schema%.stats) - df + 0.5) / (df + 0.5))* ((tf * (k + 1)/(tf + k * (1 - b + b * (len / (SELECT avgdl FROM %fts_schema%.stats))))))) AS subscore + (log(((SELECT num_docs FROM %fts_schema%.stats) - df + 0.5) / (df + 0.5) + 1) * ((tf * (k + 1)/(tf + k * (1 - b + b * (len / (SELECT avgdl FROM %fts_schema%.stats))))))) AS subscore FROM term_tf, cdocs, %fts_schema%.docs AS docs, diff --git a/extension/httpfs/include/httpfs.hpp b/extension/httpfs/include/httpfs.hpp index 1c49889b521..1ef1c11278a 100644 --- a/extension/httpfs/include/httpfs.hpp +++ b/extension/httpfs/include/httpfs.hpp @@ -10,7 +10,7 @@ namespace duckdb_httplib_openssl { struct Response; -struct Result; +class Result; class Client; } // namespace duckdb_httplib_openssl diff --git a/extension/icu/icu-strptime.cpp b/extension/icu/icu-strptime.cpp index d54d15a3700..60ad0c0de46 100644 --- a/extension/icu/icu-strptime.cpp +++ b/extension/icu/icu-strptime.cpp @@ -158,7 +158,7 @@ struct ICUStrptime : public ICUDateFunc { } } - static bind_scalar_function_t bind_strptime; + static bind_scalar_function_t bind_strptime; // NOLINT static duckdb::unique_ptr StrpTimeBindFunction(ClientContext &context, ScalarFunction &bound_function, vector> &arguments) { @@ -194,7 +194,7 @@ struct ICUStrptime : public ICUDateFunc { throw InvalidInputException("strptime format list must not be empty"); } vector formats; - bool has_tz = true; + bool has_tz = false; for (const auto &child : children) { format_string = child.ToString(); format.format_specifier = format_string; @@ -341,7 +341,7 @@ struct ICUStrptime : public ICUDateFunc { } }; -bind_scalar_function_t ICUStrptime::bind_strptime = nullptr; +bind_scalar_function_t ICUStrptime::bind_strptime = nullptr; // NOLINT struct ICUStrftime : public ICUDateFunc { static void ParseFormatSpecifier(string_t &format_str, StrfTimeFormat &format) { diff --git a/extension/icu/icu-table-range.cpp b/extension/icu/icu-table-range.cpp index 9f466a7d656..f7efd856ad9 100644 --- a/extension/icu/icu-table-range.cpp +++ b/extension/icu/icu-table-range.cpp @@ -13,14 +13,13 @@ namespace duckdb { struct ICUTableRange { using CalendarPtr = unique_ptr; - struct BindData : public TableFunctionData { - BindData(const BindData &other) + struct ICURangeBindData : public TableFunctionData { + ICURangeBindData(const ICURangeBindData &other) : TableFunctionData(other), tz_setting(other.tz_setting), cal_setting(other.cal_setting), - calendar(other.calendar->clone()), start(other.start), end(other.end), increment(other.increment), - inclusive_bound(other.inclusive_bound), greater_than_check(other.greater_than_check) { + calendar(other.calendar->clone()) { } - explicit BindData(ClientContext &context) { + explicit ICURangeBindData(ClientContext &context) { Value tz_value; if (context.TryGetCurrentSetting("TimeZone", tz_value)) { tz_setting = tz_value.ToString(); @@ -48,6 +47,15 @@ struct ICUTableRange { string tz_setting; string cal_setting; CalendarPtr calendar; + }; + + struct ICURangeLocalState : public LocalTableFunctionState { + ICURangeLocalState() { + } + + bool initialized_row = false; + idx_t current_input_row = 0; + timestamp_t current_state; timestamp_t start; timestamp_t end; @@ -55,17 +63,6 @@ struct ICUTableRange { bool inclusive_bound; bool greater_than_check; - bool Equals(const FunctionData &other_p) const override { - auto &other = other_p.Cast(); - return other.start == start && other.end == end && other.increment == increment && - other.inclusive_bound == inclusive_bound && other.greater_than_check == greater_than_check && - *calendar == *other.calendar; - } - - unique_ptr Copy() const override { - return make_uniq(*this); - } - bool Finished(timestamp_t current_value) const { if (greater_than_check) { if (inclusive_bound) { @@ -84,107 +81,129 @@ struct ICUTableRange { }; template - static unique_ptr Bind(ClientContext &context, TableFunctionBindInput &input, - vector &return_types, vector &names) { - auto result = make_uniq(context); - - auto &inputs = input.inputs; - D_ASSERT(inputs.size() == 3); - for (const auto &value : inputs) { - if (value.IsNull()) { - throw BinderException("RANGE with NULL bounds is not supported"); + static void GenerateRangeDateTimeParameters(DataChunk &input, idx_t row_id, ICURangeLocalState &result) { + input.Flatten(); + for (idx_t c = 0; c < input.ColumnCount(); c++) { + if (FlatVector::IsNull(input.data[c], row_id)) { + result.start = timestamp_t(0); + result.end = timestamp_t(0); + result.increment = interval_t(); + result.greater_than_check = true; + result.inclusive_bound = false; + return; } } - result->start = inputs[0].GetValue(); - result->end = inputs[1].GetValue(); - result->increment = inputs[2].GetValue(); + + result.start = FlatVector::GetValue(input.data[0], row_id); + result.end = FlatVector::GetValue(input.data[1], row_id); + result.increment = FlatVector::GetValue(input.data[2], row_id); // Infinities either cause errors or infinite loops, so just ban them - if (!Timestamp::IsFinite(result->start) || !Timestamp::IsFinite(result->end)) { + if (!Timestamp::IsFinite(result.start) || !Timestamp::IsFinite(result.end)) { throw BinderException("RANGE with infinite bounds is not supported"); } - if (result->increment.months == 0 && result->increment.days == 0 && result->increment.micros == 0) { + if (result.increment.months == 0 && result.increment.days == 0 && result.increment.micros == 0) { throw BinderException("interval cannot be 0!"); } // all elements should point in the same direction - if (result->increment.months > 0 || result->increment.days > 0 || result->increment.micros > 0) { - if (result->increment.months < 0 || result->increment.days < 0 || result->increment.micros < 0) { + if (result.increment.months > 0 || result.increment.days > 0 || result.increment.micros > 0) { + if (result.increment.months < 0 || result.increment.days < 0 || result.increment.micros < 0) { throw BinderException("RANGE with composite interval that has mixed signs is not supported"); } - result->greater_than_check = true; - if (result->start > result->end) { + result.greater_than_check = true; + if (result.start > result.end) { throw BinderException( "start is bigger than end, but increment is positive: cannot generate infinite series"); } } else { - result->greater_than_check = false; - if (result->start < result->end) { + result.greater_than_check = false; + if (result.start < result.end) { throw BinderException( "start is smaller than end, but increment is negative: cannot generate infinite series"); } } - return_types.push_back(inputs[0].type()); + result.inclusive_bound = GENERATE_SERIES; + } + + template + static unique_ptr Bind(ClientContext &context, TableFunctionBindInput &input, + vector &return_types, vector &names) { + auto result = make_uniq(context); + + return_types.push_back(LogicalType::TIMESTAMP_TZ); if (GENERATE_SERIES) { - // generate_series has inclusive bounds on the RHS - result->inclusive_bound = true; names.emplace_back("generate_series"); } else { - result->inclusive_bound = false; names.emplace_back("range"); } return std::move(result); } - struct State : public GlobalTableFunctionState { - explicit State(timestamp_t start_p) : current_state(start_p) { - } - - timestamp_t current_state; - bool finished = false; - }; - - static unique_ptr Init(ClientContext &context, TableFunctionInitInput &input) { - auto &bind_data = input.bind_data->Cast(); - return make_uniq(bind_data.start); + static unique_ptr RangeDateTimeLocalInit(ExecutionContext &context, + TableFunctionInitInput &input, + GlobalTableFunctionState *global_state) { + return make_uniq(); } - static void ICUTableRangeFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) { - auto &bind_data = data_p.bind_data->Cast(); + template + static OperatorResultType ICUTableRangeFunction(ExecutionContext &context, TableFunctionInput &data_p, + DataChunk &input, DataChunk &output) { + auto &bind_data = data_p.bind_data->Cast(); + auto &state = data_p.local_state->Cast(); CalendarPtr calendar_ptr(bind_data.calendar->clone()); auto calendar = calendar_ptr.get(); - auto &state = data_p.global_state->Cast(); - if (state.finished) { - return; - } - - idx_t size = 0; - auto data = FlatVector::GetData(output.data[0]); while (true) { - data[size++] = state.current_state; - state.current_state = ICUDateFunc::Add(calendar, state.current_state, bind_data.increment); - if (bind_data.Finished(state.current_state)) { - state.finished = true; - break; + if (!state.initialized_row) { + // initialize for the current input row + if (state.current_input_row >= input.size()) { + // ran out of rows + state.current_input_row = 0; + state.initialized_row = false; + return OperatorResultType::NEED_MORE_INPUT; + } + GenerateRangeDateTimeParameters(input, state.current_input_row, state); + state.initialized_row = true; + state.current_state = state.start; + } + idx_t size = 0; + auto data = FlatVector::GetData(output.data[0]); + while (true) { + if (state.Finished(state.current_state)) { + break; + } + data[size++] = state.current_state; + state.current_state = ICUDateFunc::Add(calendar, state.current_state, state.increment); + if (size >= STANDARD_VECTOR_SIZE) { + break; + } } - if (size >= STANDARD_VECTOR_SIZE) { - break; + if (size == 0) { + // move to next row + state.current_input_row++; + state.initialized_row = false; + continue; } + output.SetCardinality(size); + return OperatorResultType::HAVE_MORE_OUTPUT; } - output.SetCardinality(size); } static void AddICUTableRangeFunction(DatabaseInstance &db) { TableFunctionSet range("range"); - range.AddFunction(TableFunction({LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL}, - ICUTableRangeFunction, Bind, Init)); + TableFunction range_function({LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL}, + nullptr, Bind, nullptr, RangeDateTimeLocalInit); + range_function.in_out_function = ICUTableRangeFunction; + range.AddFunction(range_function); ExtensionUtil::AddFunctionOverload(db, range); // generate_series: similar to range, but inclusive instead of exclusive bounds on the RHS TableFunctionSet generate_series("generate_series"); - generate_series.AddFunction( - TableFunction({LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL}, - ICUTableRangeFunction, Bind, Init)); + TableFunction generate_series_function( + {LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL}, nullptr, Bind, nullptr, + RangeDateTimeLocalInit); + generate_series_function.in_out_function = ICUTableRangeFunction; + generate_series.AddFunction(generate_series_function); ExtensionUtil::AddFunctionOverload(db, generate_series); } }; diff --git a/extension/jemalloc/jemalloc/include/jemalloc/internal/jemalloc_internal_defs.h b/extension/jemalloc/jemalloc/include/jemalloc/internal/jemalloc_internal_defs.h index 46bff2794c5..e20bff79423 100644 --- a/extension/jemalloc/jemalloc/include/jemalloc/internal/jemalloc_internal_defs.h +++ b/extension/jemalloc/jemalloc/include/jemalloc/internal/jemalloc_internal_defs.h @@ -2,7 +2,7 @@ #ifndef JEMALLOC_INTERNAL_DEFS_H_ #define JEMALLOC_INTERNAL_DEFS_H_ -#if defined(__GNUC__) && !defined(__clang__) +#if defined(__GNUC__) #define _GNU_SOURCE #endif @@ -453,12 +453,12 @@ /* #undef JEMALLOC_HAVE_PTHREAD_MUTEX_ADAPTIVE_NP */ /* GNU specific sched_getcpu support */ -#if defined(__GNUC__) && !defined(__clang__) +#if defined(__GNUC__) #define JEMALLOC_HAVE_SCHED_GETCPU #endif /* GNU specific sched_setaffinity support */ -#if defined(__GNUC__) && !defined(__clang__) +#if defined(__GNUC__) #define JEMALLOC_HAVE_SCHED_SETAFFINITY #endif diff --git a/extension/parquet/parquet_reader.cpp b/extension/parquet/parquet_reader.cpp index 75017ea3584..1c2e88ef86e 100644 --- a/extension/parquet/parquet_reader.cpp +++ b/extension/parquet/parquet_reader.cpp @@ -242,7 +242,7 @@ LogicalType ParquetReader::DeriveLogicalType(const SchemaElement &s_ele, bool bi case ConvertedType::INTERVAL: return LogicalType::INTERVAL; case ConvertedType::JSON: - return LogicalType::VARCHAR; + return LogicalType::JSON(); case ConvertedType::NULL_TYPE: return LogicalTypeId::SQLNULL; case ConvertedType::MAP: diff --git a/extension/parquet/parquet_writer.cpp b/extension/parquet/parquet_writer.cpp index 10c3386136e..172bbc8f8bf 100644 --- a/extension/parquet/parquet_writer.cpp +++ b/extension/parquet/parquet_writer.cpp @@ -8,6 +8,8 @@ #ifndef DUCKDB_AMALGAMATION #include "duckdb/common/file_system.hpp" #include "duckdb/common/serializer/buffered_file_writer.hpp" +#include "duckdb/common/serializer/deserializer.hpp" +#include "duckdb/common/serializer/serializer.hpp" #include "duckdb/common/serializer/write_stream.hpp" #include "duckdb/common/string_util.hpp" #include "duckdb/function/table_function.hpp" @@ -15,8 +17,6 @@ #include "duckdb/main/connection.hpp" #include "duckdb/parser/parsed_data/create_copy_function_info.hpp" #include "duckdb/parser/parsed_data/create_table_function_info.hpp" -#include "duckdb/common/serializer/serializer.hpp" -#include "duckdb/common/serializer/deserializer.hpp" #endif namespace duckdb { @@ -216,6 +216,11 @@ CopyTypeSupport ParquetWriter::TypeIsSupported(const LogicalType &type) { void ParquetWriter::SetSchemaProperties(const LogicalType &duckdb_type, duckdb_parquet::format::SchemaElement &schema_ele) { + if (duckdb_type.IsJSONType()) { + schema_ele.converted_type = ConvertedType::JSON; + schema_ele.__isset.converted_type = true; + return; + } switch (duckdb_type.id()) { case LogicalTypeId::TINYINT: schema_ele.converted_type = ConvertedType::INT_8; @@ -578,7 +583,7 @@ void ParquetWriter::Finalize() { } // flush to disk - writer->Sync(); + writer->Close(); writer.reset(); } diff --git a/extension/sqlsmith/CMakeLists.txt b/extension/sqlsmith/CMakeLists.txt deleted file mode 100644 index 309e2e60d5d..00000000000 --- a/extension/sqlsmith/CMakeLists.txt +++ /dev/null @@ -1,21 +0,0 @@ -cmake_minimum_required(VERSION 2.8.12...3.29) - -project(SQLSmithExtension) - -include_directories(include) -include_directories(third_party/sqlsmith/include) -add_subdirectory(third_party) - -set(SQLSMITH_SOURCES - sqlsmith_extension.cpp statement_generator.cpp statement_simplifier.cpp - fuzzyduck.cpp ${SQLSMITH_OBJECT_FILES}) - -build_static_extension(sqlsmith ${SQLSMITH_SOURCES}) -set(PARAMETERS "-warnings") -build_loadable_extension(sqlsmith ${PARAMETERS} ${SQLSMITH_SOURCES}) - -install( - TARGETS sqlsmith_extension - EXPORT "${DUCKDB_EXPORT_SET}" - LIBRARY DESTINATION "${INSTALL_LIB_DIR}" - ARCHIVE DESTINATION "${INSTALL_LIB_DIR}") diff --git a/extension/sqlsmith/fuzzyduck.cpp b/extension/sqlsmith/fuzzyduck.cpp deleted file mode 100644 index 7d4f0b932e6..00000000000 --- a/extension/sqlsmith/fuzzyduck.cpp +++ /dev/null @@ -1,161 +0,0 @@ -#include "fuzzyduck.hpp" -#include "duckdb/common/random_engine.hpp" -#include "statement_generator.hpp" -#include -#include -#include - -namespace duckdb { - -FuzzyDuck::FuzzyDuck(ClientContext &context) : context(context) { -} - -FuzzyDuck::~FuzzyDuck() { -} - -void FuzzyDuck::BeginFuzzing() { - auto &random_engine = RandomEngine::Get(context); - if (seed == 0) { - seed = random_engine.NextRandomInteger(); - } - if (max_queries == 0) { - throw BinderException("Provide a max_queries argument greater than 0"); - } - if (!complete_log.empty()) { - auto &fs = FileSystem::GetFileSystem(context); - TryRemoveFile(complete_log); - complete_log_handle = - fs.OpenFile(complete_log, FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE_NEW); - } -} - -void FuzzyDuck::EndFuzzing() { - if (complete_log_handle) { - complete_log_handle->Close(); - } -} - -void FuzzyDuck::Fuzz() { - BeginFuzzing(); - for (idx_t i = 0; i < max_queries; i++) { - LogMessage("Query " + to_string(i) + "\n"); - auto query = GenerateQuery(); - RunQuery(std::move(query)); - } - EndFuzzing(); -} - -void FuzzyDuck::FuzzAllFunctions() { - StatementGenerator generator(context); - auto queries = generator.GenerateAllFunctionCalls(); - - if (max_queries == 0) { - max_queries = queries.size(); - } - - std::default_random_engine e(seed); - std::shuffle(std::begin(queries), std::end(queries), e); - BeginFuzzing(); - for (auto &query : queries) { - RunQuery(std::move(query)); - } - EndFuzzing(); -} - -string FuzzyDuck::GenerateQuery() { - LogTask("Generating query with seed " + to_string(seed)); - auto &engine = RandomEngine::Get(context); - // set the seed - engine.SetSeed(seed); - // get the next seed - seed = engine.NextRandomInteger(); - - // generate the statement - StatementGenerator generator(context); - auto statement = generator.GenerateStatement(); - return statement->ToString(); -} - -void sleep_thread(Connection *con, atomic *is_active, atomic *timed_out, idx_t timeout_duration) { - // timeout is given in seconds - // we wait 10ms per iteration, so timeout * 100 gives us the amount of - // iterations - for (size_t i = 0; i < (size_t)(timeout_duration * 100) && *is_active; i++) { - std::this_thread::sleep_for(std::chrono::milliseconds(10)); - } - if (*is_active) { - *timed_out = true; - con->Interrupt(); - } -} - -void FuzzyDuck::RunQuery(string query) { - LogQuery(query + ";"); - - Connection con(*context.db); - atomic is_active(true); - atomic timed_out(false); - std::thread interrupt_thread(sleep_thread, &con, &is_active, &timed_out, timeout); - - auto result = con.Query(query); - is_active = false; - interrupt_thread.join(); - if (timed_out) { - LogMessage("TIMEOUT"); - } else if (result->HasError()) { - LogMessage("EXECUTION ERROR: " + result->GetError()); - } else { - LogMessage("EXECUTION SUCCESS!"); - } -} - -void FuzzyDuck::TryRemoveFile(const string &path) { - auto &fs = FileSystem::GetFileSystem(context); - if (fs.FileExists(path)) { - fs.RemoveFile(path); - } -} - -void FuzzyDuck::LogMessage(const string &message) { - if (!verbose_output) { - return; - } - Printer::Print(message); -} - -void FuzzyDuck::LogTask(const string &message) { - if (verbose_output) { - LogMessage(message + "\n"); - } - LogToCurrent(message); -} - -void FuzzyDuck::LogQuery(const string &message) { - if (verbose_output) { - LogMessage(message + "\n"); - } - LogToCurrent(message); - LogToComplete(message); -} - -void FuzzyDuck::LogToCurrent(const string &message) { - if (log.empty()) { - return; - } - auto &fs = FileSystem::GetFileSystem(context); - TryRemoveFile(log); - auto file = fs.OpenFile(log, FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE_NEW); - file->Write((void *)message.c_str(), message.size()); - file->Sync(); - file->Close(); -} -void FuzzyDuck::LogToComplete(const string &message) { - if (!complete_log_handle) { - return; - } - complete_log_handle->Write((void *)message.c_str(), message.size()); - complete_log_handle->Write((void *)"\n", 1); - complete_log_handle->Sync(); -} - -} // namespace duckdb diff --git a/extension/sqlsmith/include/fuzzyduck.hpp b/extension/sqlsmith/include/fuzzyduck.hpp deleted file mode 100644 index 4393e87bc35..00000000000 --- a/extension/sqlsmith/include/fuzzyduck.hpp +++ /dev/null @@ -1,54 +0,0 @@ -//===----------------------------------------------------------------------===// -// DuckDB -// -// fuzzyduck.hpp -// -// -//===----------------------------------------------------------------------===// - -#pragma once - -#include "duckdb.hpp" -#include "duckdb/parser/query_node.hpp" - -namespace duckdb { -struct FileHandle; - -class FuzzyDuck { -public: - FuzzyDuck(ClientContext &context); - ~FuzzyDuck(); - - ClientContext &context; - uint32_t seed = 0; - idx_t max_queries = 0; - string complete_log; - string log; - bool verbose_output = false; - idx_t timeout = 30; - -public: - void Fuzz(); - void FuzzAllFunctions(); - -private: - void BeginFuzzing(); - void EndFuzzing(); - - string GenerateQuery(); - void RunQuery(string query); - - void LogMessage(const string &message); - void LogTask(const string &message); - void LogQuery(const string &message); - - void LogToCurrent(const string &message); - void LogToComplete(const string &message); - - void TryRemoveFile(const string &path); - -private: - unique_ptr complete_log_handle; -}; - -} // namespace duckdb diff --git a/extension/sqlsmith/include/sqlsmith_extension.hpp b/extension/sqlsmith/include/sqlsmith_extension.hpp deleted file mode 100644 index 4cd16f77f26..00000000000 --- a/extension/sqlsmith/include/sqlsmith_extension.hpp +++ /dev/null @@ -1,22 +0,0 @@ -//===----------------------------------------------------------------------===// -// DuckDB -// -// sqlsmith_extension.hpp -// -// -//===----------------------------------------------------------------------===// - -#pragma once - -#include "duckdb.hpp" - -namespace duckdb { - -class SqlsmithExtension : public Extension { -public: - void Load(DuckDB &db) override; - std::string Name() override; - std::string Version() const override; -}; - -} // namespace duckdb diff --git a/extension/sqlsmith/include/statement_generator.hpp b/extension/sqlsmith/include/statement_generator.hpp deleted file mode 100644 index bc96b609727..00000000000 --- a/extension/sqlsmith/include/statement_generator.hpp +++ /dev/null @@ -1,148 +0,0 @@ -//===----------------------------------------------------------------------===// -// DuckDB -// -// statement_generator.hpp -// -// -//===----------------------------------------------------------------------===// - -#pragma once - -#include "duckdb.hpp" -#include "duckdb/parser/query_node.hpp" - -namespace duckdb { -class SQLStatement; -class SelectStatement; -class InsertStatement; -class UpdateStatement; -class DeleteStatement; -class TableRef; -class SelectNode; -class SetOperationNode; -class QueryNode; -class ParsedExpression; -class ResultModifier; -class OrderModifier; -class UpdateSetInfo; - -struct GeneratorContext; - -class StatementGenerator { -public: - constexpr static idx_t MAX_DEPTH = 10; - constexpr static idx_t MAX_EXPRESSION_DEPTH = 50; - - friend class ExpressionDepthChecker; - friend class AggregateChecker; - friend class WindowChecker; - -public: - StatementGenerator(ClientContext &context); - StatementGenerator(StatementGenerator &parent); - ~StatementGenerator(); - -public: - unique_ptr GenerateStatement(); - - vector GenerateAllFunctionCalls(); - -private: - unique_ptr GenerateStatement(StatementType type); - - unique_ptr GenerateSelect(); - unique_ptr GenerateCreate(); - unique_ptr GenerateQueryNode(); - - unique_ptr GenerateCreateInfo(); - - void GenerateCTEs(QueryNode &node); - unique_ptr GenerateTableRef(); - unique_ptr GenerateExpression(); - - unique_ptr GenerateBaseTableRef(); - unique_ptr GenerateExpressionListRef(); - unique_ptr GenerateJoinRef(); - unique_ptr GenerateSubqueryRef(); - unique_ptr GenerateTableFunctionRef(); - unique_ptr GeneratePivotRef(); - - unique_ptr GenerateConstant(); - unique_ptr GenerateColumnRef(); - unique_ptr GenerateFunction(); - unique_ptr GenerateOperator(); - unique_ptr GenerateWindowFunction(optional_ptr function = nullptr); - unique_ptr GenerateConjunction(); - unique_ptr GenerateStar(); - unique_ptr GenerateLambda(); - unique_ptr GenerateSubquery(); - unique_ptr GenerateCast(); - unique_ptr GenerateBetween(); - unique_ptr GenerateComparison(); - unique_ptr GeneratePositionalReference(); - unique_ptr GenerateCase(); - - unique_ptr GenerateOrderBy(); - - LogicalType GenerateLogicalType(); - - void GenerateAllScalar(ScalarFunctionCatalogEntry &scalar_function, vector &result); - void GenerateAllAggregate(AggregateFunctionCatalogEntry &aggregate_function, vector &result); - string GenerateTestAllTypes(BaseScalarFunction &base_function); - string GenerateTestVectorTypes(BaseScalarFunction &base_function); - string GenerateCast(const LogicalType &target, const string &source_name, bool add_varchar); - bool FunctionArgumentsAlwaysNull(const string &name); - - idx_t RandomValue(idx_t max); - bool RandomBoolean(); - //! Returns true with a percentage change (0-100) - bool RandomPercentage(idx_t percentage); - string RandomString(idx_t length); - unique_ptr RandomExpression(idx_t percentage); - - //! Generate identifier for a column or parent using "t" or "c" prefixes. ie. t0, or c0 - string GenerateIdentifier(); - string GenerateTableIdentifier(); - string GenerateSchemaIdentifier(); - string GenerateViewIdentifier(); - - //! using the parent generate a relation name. ie. t0 - string GenerateRelationName(); - //! using the parent, generate a valid column name. ie. c0 - string GenerateColumnName(); - idx_t GetIndex(); - - Value GenerateConstantValue(); - - ExpressionType GenerateComparisonType(); - - //! used to create columns when creating new tables; - -private: - ClientContext &context; - optional_ptr parent; - unique_ptr current_statement; - vector current_relation_names; - vector current_column_names; - - std::shared_ptr generator_context; - idx_t index = 0; - idx_t depth = 0; - idx_t expression_depth = 0; - - bool in_window = false; - bool in_aggregate = false; - - std::shared_ptr GetDatabaseState(ClientContext &context); - vector> GenerateChildren(idx_t min, idx_t max); - - template - const T &Choose(const vector &entries) { - if (entries.empty()) { - throw InternalException("Attempting to choose from an empty vector"); - } - return entries[RandomValue(entries.size())]; - } -}; - -} // namespace duckdb diff --git a/extension/sqlsmith/include/statement_simplifier.hpp b/extension/sqlsmith/include/statement_simplifier.hpp deleted file mode 100644 index 0f238437fe8..00000000000 --- a/extension/sqlsmith/include/statement_simplifier.hpp +++ /dev/null @@ -1,89 +0,0 @@ -//===----------------------------------------------------------------------===// -// DuckDB -// -// statement_simplifier.hpp -// -// -//===----------------------------------------------------------------------===// - -#pragma once - -#include "duckdb.hpp" -#include "duckdb/parser/query_node.hpp" - -namespace duckdb { -class SQLStatement; -class SelectStatement; -class InsertStatement; -class UpdateStatement; -class DeleteStatement; -class TableRef; -class SelectNode; -class SetOperationNode; -class QueryNode; -class ParsedExpression; -class ResultModifier; -class OrderModifier; -class UpdateSetInfo; -class GroupByNode; - -class StatementSimplifier { -public: - StatementSimplifier(SQLStatement &statement_p, vector &result_p); - - SQLStatement &statement; - vector &result; - -public: - void Simplify(SQLStatement &stmt); - -private: - void Simplify(SelectStatement &stmt); - void Simplify(InsertStatement &stmt); - void Simplify(UpdateStatement &stmt); - void Simplify(DeleteStatement &stmt); - - void Simplification(); - - template - void SimplifyList(vector &list, bool is_optional = true); - template - void SimplifyMap(T &map); - template - void SimplifySet(T &set); - - template - void SimplifyReplace(T &element, T &other); - - template - void SimplifyOptional(duckdb::unique_ptr &opt); - template - void SimplifyAlias(T &input); - template - void SimplifyEnum(T &enum_ref, T default_value); - - void Simplify(unique_ptr &ref); - - void Simplify(SelectNode &node); - void Simplify(SetOperationNode &node); - void Simplify(unique_ptr &node); - - void Simplify(ResultModifier &modifier); - void Simplify(OrderModifier &modifier); - - void SimplifyExpression(duckdb::unique_ptr &expr); - void SimplifyOptionalExpression(duckdb::unique_ptr &expr); - void SimplifyChildExpression(duckdb::unique_ptr &expr, unique_ptr &child); - void SimplifyExpressionList(duckdb::unique_ptr &expr, - vector> &expression_list); - void SimplifyExpressionList(vector> &expression_list, bool is_optional = true); - void Simplify(CommonTableExpressionMap &cte_map); - void Simplify(GroupByNode &groups); - - void Simplify(UpdateSetInfo &info); - -private: - vector>> query_nodes; -}; - -} // namespace duckdb diff --git a/extension/sqlsmith/sqlsmith_extension.cpp b/extension/sqlsmith/sqlsmith_extension.cpp deleted file mode 100644 index 07167e941eb..00000000000 --- a/extension/sqlsmith/sqlsmith_extension.cpp +++ /dev/null @@ -1,231 +0,0 @@ -#define DUCKDB_EXTENSION_MAIN - -#include "sqlsmith_extension.hpp" -#include "sqlsmith.hh" -#include "statement_simplifier.hpp" -#include "fuzzyduck.hpp" - -#ifndef DUCKDB_AMALGAMATION -#include "duckdb/function/table_function.hpp" -#include "duckdb/parser/parser.hpp" -#include "duckdb/main/extension_util.hpp" -#endif - -namespace duckdb { - -struct SQLSmithFunctionData : public TableFunctionData { - SQLSmithFunctionData() { - } - - int32_t seed = -1; - idx_t max_queries = 0; - bool exclude_catalog = false; - bool dump_all_queries = false; - bool dump_all_graphs = false; - bool verbose_output = false; - string complete_log; - string log; - bool finished = false; -}; - -static duckdb::unique_ptr SQLSmithBind(ClientContext &context, TableFunctionBindInput &input, - vector &return_types, vector &names) { - auto result = make_uniq(); - for (auto &kv : input.named_parameters) { - if (kv.first == "seed") { - result->seed = IntegerValue::Get(kv.second); - } else if (kv.first == "max_queries") { - result->max_queries = UBigIntValue::Get(kv.second); - } else if (kv.first == "exclude_catalog") { - result->exclude_catalog = BooleanValue::Get(kv.second); - } else if (kv.first == "dump_all_queries") { - result->dump_all_queries = BooleanValue::Get(kv.second); - } else if (kv.first == "dump_all_graphs") { - result->dump_all_graphs = BooleanValue::Get(kv.second); - } else if (kv.first == "verbose_output") { - result->verbose_output = BooleanValue::Get(kv.second); - } else if (kv.first == "complete_log") { - result->complete_log = StringValue::Get(kv.second); - } else if (kv.first == "log") { - result->log = StringValue::Get(kv.second); - } - } - return_types.emplace_back(LogicalType::BOOLEAN); - names.emplace_back("Success"); - return std::move(result); -} - -static void SQLSmithFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) { - auto &data = data_p.bind_data->CastNoConst(); - if (data.finished) { - return; - } - - duckdb_sqlsmith::SQLSmithOptions options; - options.seed = data.seed; - options.max_queries = data.max_queries; - options.exclude_catalog = data.exclude_catalog; - options.dump_all_queries = data.dump_all_queries; - options.dump_all_graphs = data.dump_all_graphs; - options.verbose_output = data.verbose_output; - options.complete_log = data.complete_log; - options.log = data.log; - duckdb_sqlsmith::run_sqlsmith(DatabaseInstance::GetDatabase(context), options); - - data.finished = true; -} - -struct ReduceSQLFunctionData : public TableFunctionData { - ReduceSQLFunctionData() { - } - - vector statements; - idx_t offset = 0; -}; - -static duckdb::unique_ptr ReduceSQLBind(ClientContext &context, TableFunctionBindInput &input, - vector &return_types, vector &names) { - return_types.emplace_back(LogicalType::VARCHAR); - names.emplace_back("sql"); - - auto result = make_uniq(); - auto sql = input.inputs[0].ToString(); - Parser parser; - parser.ParseQuery(sql); - if (parser.statements.size() != 1) { - throw InvalidInputException("reduce_sql_statement requires a single statement as parameter"); - } - auto &statement = *parser.statements[0]; - StatementSimplifier simplifier(statement, result->statements); - simplifier.Simplify(statement); - return std::move(result); -} - -static void ReduceSQLFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) { - auto &data = data_p.bind_data->CastNoConst(); - if (data.offset >= data.statements.size()) { - // finished returning values - return; - } - // start returning values - // either fill up the chunk or return all the remaining columns - idx_t count = 0; - while (data.offset < data.statements.size() && count < STANDARD_VECTOR_SIZE) { - auto &entry = data.statements[data.offset++]; - output.data[0].SetValue(count, Value(entry)); - count++; - } - output.SetCardinality(count); -} - -struct FuzzyDuckFunctionData : public TableFunctionData { - FuzzyDuckFunctionData(ClientContext &context) : fuzzer(context) { - } - - FuzzyDuck fuzzer; - bool finished = false; -}; - -static duckdb::unique_ptr FuzzyDuckBind(ClientContext &context, TableFunctionBindInput &input, - vector &return_types, vector &names) { - auto result = make_uniq(context); - for (auto &kv : input.named_parameters) { - if (kv.first == "seed") { - result->fuzzer.seed = IntegerValue::Get(kv.second); - } else if (kv.first == "max_queries") { - result->fuzzer.max_queries = UBigIntValue::Get(kv.second); - } else if (kv.first == "complete_log") { - result->fuzzer.complete_log = StringValue::Get(kv.second); - } else if (kv.first == "log") { - result->fuzzer.log = StringValue::Get(kv.second); - } else if (kv.first == "verbose_output") { - result->fuzzer.verbose_output = BooleanValue::Get(kv.second); - } - } - return_types.emplace_back(LogicalType::BOOLEAN); - names.emplace_back("Success"); - return std::move(result); -} - -static void FuzzyDuckFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) { - auto &data = data_p.bind_data->CastNoConst(); - if (data.finished) { - return; - } - - data.fuzzer.Fuzz(); - data.finished = true; -} - -static void FuzzAllFunctions(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) { - auto &data = data_p.bind_data->CastNoConst(); - if (data.finished) { - return; - } - - data.fuzzer.FuzzAllFunctions(); - data.finished = true; -} - -void SqlsmithExtension::Load(DuckDB &db) { - auto &db_instance = *db.instance; - - TableFunction sqlsmith_func("sqlsmith", {}, SQLSmithFunction, SQLSmithBind); - sqlsmith_func.named_parameters["seed"] = LogicalType::INTEGER; - sqlsmith_func.named_parameters["max_queries"] = LogicalType::UBIGINT; - sqlsmith_func.named_parameters["exclude_catalog"] = LogicalType::BOOLEAN; - sqlsmith_func.named_parameters["dump_all_queries"] = LogicalType::BOOLEAN; - sqlsmith_func.named_parameters["dump_all_graphs"] = LogicalType::BOOLEAN; - sqlsmith_func.named_parameters["verbose_output"] = LogicalType::BOOLEAN; - sqlsmith_func.named_parameters["complete_log"] = LogicalType::VARCHAR; - sqlsmith_func.named_parameters["log"] = LogicalType::VARCHAR; - ExtensionUtil::RegisterFunction(db_instance, sqlsmith_func); - - TableFunction fuzzy_duck_fun("fuzzyduck", {}, FuzzyDuckFunction, FuzzyDuckBind); - fuzzy_duck_fun.named_parameters["seed"] = LogicalType::INTEGER; - fuzzy_duck_fun.named_parameters["max_queries"] = LogicalType::UBIGINT; - fuzzy_duck_fun.named_parameters["log"] = LogicalType::VARCHAR; - fuzzy_duck_fun.named_parameters["complete_log"] = LogicalType::VARCHAR; - fuzzy_duck_fun.named_parameters["verbose_output"] = LogicalType::BOOLEAN; - ExtensionUtil::RegisterFunction(db_instance, fuzzy_duck_fun); - - TableFunction fuzz_all_functions("fuzz_all_functions", {}, FuzzAllFunctions, FuzzyDuckBind); - fuzz_all_functions.named_parameters["seed"] = LogicalType::INTEGER; - fuzz_all_functions.named_parameters["log"] = LogicalType::VARCHAR; - fuzz_all_functions.named_parameters["complete_log"] = LogicalType::VARCHAR; - fuzz_all_functions.named_parameters["verbose_output"] = LogicalType::BOOLEAN; - ExtensionUtil::RegisterFunction(db_instance, fuzz_all_functions); - - TableFunction reduce_sql_function("reduce_sql_statement", {LogicalType::VARCHAR}, ReduceSQLFunction, ReduceSQLBind); - ExtensionUtil::RegisterFunction(db_instance, reduce_sql_function); -} - -std::string SqlsmithExtension::Name() { - return "sqlsmith"; -} - -std::string SqlsmithExtension::Version() const { -#ifdef EXT_VERSION_SQLSMITH - return EXT_VERSION_SQLSMITH; -#else - return ""; -#endif -} - -} // namespace duckdb - -extern "C" { - -DUCKDB_EXTENSION_API void sqlsmith_init(duckdb::DatabaseInstance &db) { - duckdb::DuckDB db_wrapper(db); - db_wrapper.LoadExtension(); -} - -DUCKDB_EXTENSION_API const char *sqlsmith_version() { - return duckdb::DuckDB::LibraryVersion(); -} -} - -#ifndef DUCKDB_EXTENSION_MAIN -#error DUCKDB_EXTENSION_MAIN not defined -#endif diff --git a/extension/sqlsmith/statement_generator.cpp b/extension/sqlsmith/statement_generator.cpp deleted file mode 100644 index e5053b3a622..00000000000 --- a/extension/sqlsmith/statement_generator.cpp +++ /dev/null @@ -1,1261 +0,0 @@ -#include "statement_generator.hpp" - -#include "duckdb/catalog/catalog_entry/list.hpp" -#include "duckdb/common/random_engine.hpp" -#include "duckdb/common/types/uuid.hpp" -#include "duckdb/function/table/system_functions.hpp" -#include "duckdb/parser/expression/list.hpp" -#include "duckdb/parser/parsed_data/create_schema_info.hpp" -#include "duckdb/parser/parsed_data/create_table_info.hpp" -#include "duckdb/parser/parsed_data/create_view_info.hpp" -#include "duckdb/parser/parsed_data/create_function_info.hpp" -#include "duckdb/parser/parsed_data/create_type_info.hpp" -#include "duckdb/parser/parsed_expression_iterator.hpp" -#include "duckdb/parser/query_node/select_node.hpp" -#include "duckdb/parser/query_node/set_operation_node.hpp" -#include "duckdb/parser/statement/create_statement.hpp" -#include "duckdb/parser/statement/delete_statement.hpp" -#include "duckdb/parser/statement/insert_statement.hpp" -#include "duckdb/parser/statement/select_statement.hpp" -#include "duckdb/parser/statement/update_statement.hpp" -#include "duckdb/parser/tableref/list.hpp" - -namespace duckdb { - -struct GeneratorContext { - vector test_types; - vector> scalar_functions; - vector> table_functions; - vector> pragma_functions; - vector> tables_and_views; -}; - -StatementGenerator::StatementGenerator(ClientContext &context) : context(context), parent(nullptr), depth(0) { - generator_context = GetDatabaseState(context); -} - -StatementGenerator::StatementGenerator(StatementGenerator &parent_p) - : context(parent_p.context), parent(&parent_p), generator_context(parent_p.generator_context), - depth(parent_p.depth + 1) { - if (depth > MAX_DEPTH) { - throw InternalException("depth too high"); - } -} - -StatementGenerator::~StatementGenerator() { -} - -std::shared_ptr StatementGenerator::GetDatabaseState(ClientContext &context) { - auto result = std::make_shared(); - result->test_types = TestAllTypesFun::GetTestTypes(); - - auto schemas = Catalog::GetAllSchemas(context); - // extract the functions - for (auto &schema_ref : schemas) { - auto &schema = schema_ref.get(); - schema.Scan(context, CatalogType::SCALAR_FUNCTION_ENTRY, - [&](CatalogEntry &entry) { result->scalar_functions.push_back(entry); }); - schema.Scan(context, CatalogType::TABLE_FUNCTION_ENTRY, [&](CatalogEntry &entry) { - // don't include fuzz functions - if (entry.name.find("fuzzyduck") == std::string::npos && - entry.name.find("fuzz_all_functions") == std::string::npos && - entry.name.find("reduce_sql_statement") == std::string::npos && - entry.name.find("sqlsmith") == std::string::npos) { - result->table_functions.push_back(entry); - } - }); - schema.Scan(context, CatalogType::PRAGMA_FUNCTION_ENTRY, - [&](CatalogEntry &entry) { result->pragma_functions.push_back(entry); }); - schema.Scan(context, CatalogType::TABLE_ENTRY, [&](CatalogEntry &entry) { - if (entry.internal) { - return; - } - result->tables_and_views.push_back(entry); - }); - } - return result; -} - -unique_ptr StatementGenerator::GenerateStatement() { - if (RandomPercentage(80)) { - return GenerateStatement(StatementType::SELECT_STATEMENT); - } - return GenerateStatement(StatementType::CREATE_STATEMENT); -} - -unique_ptr StatementGenerator::GenerateStatement(StatementType type) { - switch (type) { - case StatementType::SELECT_STATEMENT: - return GenerateSelect(); - case StatementType::CREATE_STATEMENT: - return GenerateCreate(); - default: - throw InternalException("Unsupported type"); - } -} - -//===--------------------------------------------------------------------===// -// Statements -//===--------------------------------------------------------------------===// -unique_ptr StatementGenerator::GenerateSelect() { - auto select = make_uniq(); - select->node = GenerateQueryNode(); - return select; -} - -unique_ptr StatementGenerator::GenerateCreate() { - auto create = make_uniq(); - create->info = GenerateCreateInfo(); - return create; -} - -//===--------------------------------------------------------------------===// -// Create Info Node -//===--------------------------------------------------------------------===// - -unique_ptr StatementGenerator::GenerateCreateInfo() { - switch (RandomValue(4)) { - case 0: { - auto info = make_uniq(); - info->name = RandomString(5); - idx_t num_enums = RandomValue(10); - auto Enum_Vector = Vector(LogicalType::VARCHAR, num_enums); - for (idx_t i = 0; i < num_enums; i++) { - Enum_Vector.SetValue(i, Value(RandomString(10))); - } - info->type = LogicalType::ENUM("My_enum", Enum_Vector, num_enums); - return std::move(info); - } - case 1: { - auto info = make_uniq(); - info->catalog = INVALID_CATALOG; - info->schema = DEFAULT_SCHEMA; - info->table = GenerateTableIdentifier(); - if (RandomPercentage(50)) { - info->query = GenerateSelect(); - } else { - idx_t num_cols = RandomValue(1000); - for (idx_t i = 0; i < num_cols; i++) { - info->columns.AddColumn(ColumnDefinition(GenerateIdentifier(), GenerateLogicalType())); - } - } - // TODO: add constraints to the columns (primary keys etc.); - return std::move(info); - } - case 2: { - auto info = make_uniq(); - info->catalog = INVALID_CATALOG; - info->on_conflict = OnCreateConflict::REPLACE_ON_CONFLICT; - info->schema = GenerateSchemaIdentifier(); - return std::move(info); - } - case 3: { - auto info = make_uniq(); - info->view_name = GenerateViewIdentifier(); - info->query = GenerateSelect(); - // TODO: add support for aliases in the view. - return std::move(info); - } - default: - break; - } - throw InternalException("Unsupported Create Info Type"); -} - -//===--------------------------------------------------------------------===// -// Query Node -//===--------------------------------------------------------------------===// -void StatementGenerator::GenerateCTEs(QueryNode &node) { - if (depth > 0) { - return; - } - while (RandomPercentage(20)) { - auto cte = make_uniq(); - cte->query = unique_ptr_cast(GenerateSelect()); - for (idx_t i = 0; i < 1 + RandomValue(10); i++) { - cte->aliases.push_back(GenerateIdentifier()); - } - node.cte_map.map[GenerateTableIdentifier()] = std::move(cte); - } -} -unique_ptr StatementGenerator::GenerateQueryNode() { - unique_ptr result; - bool is_distinct = false; - if (RandomPercentage(70)) { - // select node - auto select_node = make_uniq(); - // generate CTEs - GenerateCTEs(*select_node); - - is_distinct = RandomPercentage(30); - if (RandomPercentage(95)) { - select_node->from_table = GenerateTableRef(); - } - select_node->select_list = GenerateChildren(1, 10); - select_node->where_clause = RandomExpression(60); - select_node->having = RandomExpression(25); - if (RandomPercentage(30)) { - select_node->groups.group_expressions = GenerateChildren(1, 5); - auto group_count = select_node->groups.group_expressions.size(); - if (RandomPercentage(70)) { - // single GROUP BY - GroupingSet set; - for (idx_t i = 0; i < group_count; i++) { - set.insert(i); - } - select_node->groups.grouping_sets.push_back(std::move(set)); - } else { - // multiple grouping sets - while (true) { - GroupingSet set; - while (true) { - set.insert(RandomValue(group_count)); - if (RandomPercentage(50)) { - break; - } - } - select_node->groups.grouping_sets.push_back(std::move(set)); - if (RandomPercentage(70)) { - break; - } - } - } - } - select_node->qualify = RandomExpression(10); - select_node->aggregate_handling = - RandomPercentage(10) ? AggregateHandling::FORCE_AGGREGATES : AggregateHandling::STANDARD_HANDLING; - if (RandomPercentage(10)) { - auto sample = make_uniq(); - sample->is_percentage = RandomPercentage(50); - if (sample->is_percentage) { - sample->sample_size = Value::BIGINT(RandomValue(100)); - } else { - sample->sample_size = Value::BIGINT(RandomValue(99999)); - } - sample->method = Choose( - {SampleMethod::BERNOULLI_SAMPLE, SampleMethod::RESERVOIR_SAMPLE, SampleMethod::SYSTEM_SAMPLE}); - select_node->sample = std::move(sample); - } - result = std::move(select_node); - } else { - auto setop = make_uniq(); - GenerateCTEs(*setop); - setop->setop_type = Choose({SetOperationType::EXCEPT, SetOperationType::INTERSECT, - SetOperationType::UNION, SetOperationType::UNION_BY_NAME}); - setop->left = GenerateQueryNode(); - setop->right = GenerateQueryNode(); - switch (setop->setop_type) { - case SetOperationType::EXCEPT: - case SetOperationType::INTERSECT: - is_distinct = true; - break; - case SetOperationType::UNION: - case SetOperationType::UNION_BY_NAME: - is_distinct = RandomBoolean(); - break; - default: - throw InternalException("Unsupported set operation type"); - } - result = std::move(setop); - } - - if (is_distinct) { - result->modifiers.push_back(make_uniq()); - } - if (RandomPercentage(20)) { - result->modifiers.push_back(GenerateOrderBy()); - } - if (RandomPercentage(20)) { - if (RandomPercentage(50)) { - auto limit_percent_modifier = make_uniq(); - if (RandomPercentage(30)) { - limit_percent_modifier->limit = GenerateExpression(); - } else if (RandomPercentage(30)) { - limit_percent_modifier->offset = GenerateExpression(); - } else { - limit_percent_modifier->limit = GenerateExpression(); - limit_percent_modifier->offset = GenerateExpression(); - } - result->modifiers.push_back(std::move(limit_percent_modifier)); - } else { - auto limit_modifier = make_uniq(); - if (RandomPercentage(30)) { - limit_modifier->limit = GenerateExpression(); - } else if (RandomPercentage(30)) { - limit_modifier->offset = GenerateExpression(); - } else { - limit_modifier->limit = GenerateExpression(); - limit_modifier->offset = GenerateExpression(); - } - result->modifiers.push_back(std::move(limit_modifier)); - } - } - return result; -} - -//===--------------------------------------------------------------------===// -// Table Ref -//===--------------------------------------------------------------------===// -unique_ptr StatementGenerator::GenerateTableRef() { - if (RandomPercentage(60)) { - return GenerateBaseTableRef(); - } - if (RandomPercentage(20)) { - return GenerateExpressionListRef(); - } - if (RandomPercentage(40)) { - return GenerateJoinRef(); - } - switch (RandomValue(3)) { - case 0: - return GenerateSubqueryRef(); - case 1: - return GenerateTableFunctionRef(); - case 2: - return GeneratePivotRef(); - default: - throw InternalException("StatementGenerator::GenerateTableRef"); - } -} - -unique_ptr StatementGenerator::GenerateBaseTableRef() { - if (generator_context->tables_and_views.empty()) { - return GenerateExpressionListRef(); - } - auto &entry_ref = Choose(generator_context->tables_and_views); - auto &entry = entry_ref.get(); - auto result = make_uniq(); - idx_t column_count; - switch (entry.type) { - case CatalogType::TABLE_ENTRY: { - auto &table = entry.Cast(); - column_count = table.GetColumns().LogicalColumnCount(); - break; - } - case CatalogType::VIEW_ENTRY: { - auto &view = entry.Cast(); - column_count = view.types.size(); - break; - } - default: - throw InternalException("StatementGenerator::GenerateBaseTableRef"); - } - for (idx_t i = 0; i < column_count; i++) { - result->column_name_alias.push_back(GenerateIdentifier()); - } - result->alias = GenerateTableIdentifier(); - result->table_name = entry.name; - return std::move(result); -} - -unique_ptr StatementGenerator::GenerateExpressionListRef() { - auto result = make_uniq(); - auto column_count = 1 + RandomValue(10); - for (idx_t r = 0; r < 1 + RandomValue(10); r++) { - vector> values; - for (idx_t c = 0; c < column_count; c++) { - values.push_back(GenerateConstant()); - } - result->values.push_back(std::move(values)); - } - return std::move(result); -} - -unique_ptr StatementGenerator::GenerateJoinRef() { - JoinRefType join_ref; - if (RandomPercentage(10)) { - join_ref = JoinRefType::CROSS; - } else if (RandomPercentage(10)) { - join_ref = JoinRefType::ASOF; - } else if (RandomPercentage(10)) { - join_ref = JoinRefType::NATURAL; - } else if (RandomPercentage(10)) { - join_ref = JoinRefType::POSITIONAL; - } else { - join_ref = JoinRefType::REGULAR; - } - auto join = make_uniq(join_ref); - join->left = GenerateTableRef(); - join->right = GenerateTableRef(); - if (join_ref != JoinRefType::CROSS && join_ref != JoinRefType::NATURAL) { - if (RandomPercentage(70)) { - join->condition = GenerateExpression(); - } else { - while (true) { - join->using_columns.push_back(GenerateColumnName()); - if (RandomPercentage(50)) { - break; - } - } - } - } - join->type = Choose( - {JoinType::LEFT, JoinType::RIGHT, JoinType::INNER, JoinType::OUTER, JoinType::SEMI, JoinType::ANTI}); - return std::move(join); -} - -unique_ptr StatementGenerator::GenerateSubqueryRef() { - if (depth >= MAX_DEPTH) { - return GenerateBaseTableRef(); - } - unique_ptr subquery; - { - StatementGenerator child_generator(*this); - subquery = unique_ptr_cast(child_generator.GenerateSelect()); - for (auto &col : child_generator.current_column_names) { - current_column_names.push_back(std::move(col)); - } - } - auto result = make_uniq(std::move(subquery), GenerateTableIdentifier()); - return std::move(result); -} - -unique_ptr StatementGenerator::GenerateTableFunctionRef() { - auto function = make_uniq(); - auto &table_function_ref = Choose(generator_context->table_functions); - auto &entry = table_function_ref.get().Cast(); - auto table_function = entry.functions.GetFunctionByOffset(RandomValue(entry.functions.Size())); - - auto result = make_uniq(); - vector> children; - for (idx_t i = 0; i < table_function.arguments.size(); i++) { - children.push_back(GenerateConstant()); - } - vector names; - for (auto &e : table_function.named_parameters) { - names.push_back(e.first); - } - while (!names.empty() && RandomPercentage(50)) { - auto name = Choose(names); - names.erase(std::find(names.begin(), names.end(), name)); - auto expr = GenerateConstant(); - expr->alias = name; - children.push_back(std::move(expr)); - } - result->function = make_uniq(entry.name, std::move(children)); - for (idx_t i = 0; i < 1 + RandomValue(9); i++) { - result->column_name_alias.push_back(GenerateIdentifier()); - } - result->alias = GenerateTableIdentifier(); - return std::move(result); -} - -unique_ptr StatementGenerator::GeneratePivotRef() { - auto pivot = make_uniq(); - pivot->source = GenerateTableRef(); - bool is_pivot = RandomPercentage(50); - if (is_pivot) { - // pivot - // aggregates - while (true) { - pivot->aggregates.push_back(GenerateFunction()); - if (RandomPercentage(50)) { - break; - } - } - while (RandomPercentage(50)) { - pivot->groups.push_back(GenerateColumnName()); - } - } else { - // unpivot - while (true) { - pivot->unpivot_names.push_back(GenerateColumnName()); - if (RandomPercentage(50)) { - break; - } - } - pivot->include_nulls = RandomBoolean(); - } - while (true) { - PivotColumn col; - idx_t number_of_columns = 1 + RandomValue(2); - for (idx_t i = 0; i < number_of_columns; i++) { - if (is_pivot) { - col.pivot_expressions.push_back(GenerateExpression()); - } else { - col.unpivot_names.push_back(GenerateColumnName()); - } - } - while (true) { - PivotColumnEntry entry; - for (idx_t i = 0; i < number_of_columns; i++) { - entry.values.push_back(GenerateConstantValue()); - } - col.entries.push_back(std::move(entry)); - if (RandomPercentage(50)) { - break; - } - } - pivot->pivots.push_back(std::move(col)); - if (RandomPercentage(70)) { - break; - } - } - return std::move(pivot); -} - -//===--------------------------------------------------------------------===// -// Expressions -//===--------------------------------------------------------------------===// -class ExpressionDepthChecker { -public: - explicit ExpressionDepthChecker(StatementGenerator &generator) : generator(generator) { - generator.expression_depth++; - } - ~ExpressionDepthChecker() { - generator.expression_depth--; - } - - StatementGenerator &generator; -}; - -unique_ptr StatementGenerator::GenerateExpression() { - ExpressionDepthChecker checker(*this); - if (RandomPercentage(50) || RandomPercentage(expression_depth + depth * 5)) { - return GenerateColumnRef(); - } - if (RandomPercentage(30)) { - return GenerateConstant(); - } - if (RandomPercentage(3)) { - return GenerateSubquery(); - } - switch (RandomValue(9)) { - case 0: - return GenerateOperator(); - case 1: - return GenerateFunction(); - case 2: - return GenerateWindowFunction(); - case 3: - return GenerateConjunction(); - case 4: - return GenerateStar(); - case 5: - return GenerateCast(); - case 6: - return GenerateBetween(); - case 7: - return GenerateComparison(); - case 8: - return GeneratePositionalReference(); - default: - throw InternalException("StatementGenerator::GenerateExpression"); - } -} - -Value StatementGenerator::GenerateConstantValue() { - if (RandomPercentage(50)) { - return Value::BIGINT(RandomValue(9999)); - } - if (RandomPercentage(30)) { - return Value(UUID::ToString(UUID::GenerateRandomUUID(RandomEngine::Get(context)))); - } - auto &val = Choose(generator_context->test_types); - Value constant_val; - switch (RandomValue(3)) { - case 0: - constant_val = val.min_value; - break; - case 1: - constant_val = val.max_value; - break; - case 2: - constant_val = Value(val.type); - break; - default: - throw InternalException("StatementGenerator::GenerateConstant"); - } - return constant_val; -} - -unique_ptr StatementGenerator::GenerateConstant() { - return make_uniq(GenerateConstantValue()); -} - -LogicalType StatementGenerator::GenerateLogicalType() { - return Choose(generator_context->test_types).type; -} - -unique_ptr StatementGenerator::GenerateColumnRef() { - auto column_name = GenerateColumnName(); - if (column_name.empty()) { - return GenerateConstant(); - } - return make_uniq(std::move(column_name)); -} - -class AggregateChecker { -public: - explicit AggregateChecker(StatementGenerator &generator) : generator(generator) { - generator.in_aggregate = true; - } - ~AggregateChecker() { - generator.in_aggregate = false; - } - - StatementGenerator &generator; -}; - -unique_ptr StatementGenerator::GenerateFunction() { - // get a random function - auto &function_ref = Choose(generator_context->scalar_functions); - auto &function = function_ref.get(); - string name; - idx_t min_parameters; - idx_t max_parameters; - unique_ptr filter; - unique_ptr order_bys; - bool distinct = false; - unique_ptr checker; - vector arguments; - switch (function.type) { - case CatalogType::SCALAR_FUNCTION_ENTRY: { - auto &scalar_entry = function.Cast(); - auto actual_function = scalar_entry.functions.GetFunctionByOffset(RandomValue(scalar_entry.functions.Size())); - - name = scalar_entry.name; - arguments = actual_function.arguments; - min_parameters = actual_function.arguments.size(); - max_parameters = min_parameters; - if (actual_function.varargs.id() != LogicalTypeId::INVALID) { - max_parameters += 5; - } - break; - } - case CatalogType::AGGREGATE_FUNCTION_ENTRY: { - auto &aggregate_entry = function.Cast(); - auto actual_function = - aggregate_entry.functions.GetFunctionByOffset(RandomValue(aggregate_entry.functions.Size())); - - name = aggregate_entry.name; - min_parameters = actual_function.arguments.size(); - max_parameters = min_parameters; - if (actual_function.varargs.id() != LogicalTypeId::INVALID) { - max_parameters += 5; - } - if (RandomPercentage(10) && !in_window) { - return GenerateWindowFunction(&actual_function); - } - if (in_aggregate) { - // we cannot nest aggregates - return GenerateColumnRef(); - } - checker = make_uniq(*this); - filter = RandomExpression(10); - if (RandomPercentage(10)) { - // generate order by - order_bys = GenerateOrderBy(); - } - if (RandomPercentage(10)) { - distinct = true; - } - break; - } - case CatalogType::MACRO_ENTRY: { - auto ¯o_entry = function.Cast(); - name = macro_entry.name; - min_parameters = macro_entry.function->parameters.size(); - max_parameters = min_parameters; - break; - } - default: - throw InternalException("StatementGenerator::GenerateFunction"); - } - auto children = GenerateChildren(min_parameters, max_parameters); - // push lambda expressions - for (idx_t i = 0; i < arguments.size(); i++) { - if (arguments[i].id() == LogicalTypeId::LAMBDA) { - children[i] = GenerateLambda(); - } - } - // FIXME: add export_state - return make_uniq(std::move(name), std::move(children), std::move(filter), std::move(order_bys), - distinct); -} - -unique_ptr StatementGenerator::GenerateOrderBy() { - auto result = make_uniq(); - while (true) { - auto order_type = Choose({OrderType::ASCENDING, OrderType::DESCENDING, OrderType::ORDER_DEFAULT}); - auto null_type = Choose( - {OrderByNullType::NULLS_FIRST, OrderByNullType::NULLS_LAST, OrderByNullType::ORDER_DEFAULT}); - result->orders.emplace_back(order_type, null_type, GenerateExpression()); - // continue with a random chance - if (RandomPercentage(50)) { - break; - } - } - return result; -} - -unique_ptr StatementGenerator::GenerateOperator() { - ExpressionType type; - idx_t min_parameters; - idx_t max_parameters; - switch (RandomValue(9)) { - case 0: - type = ExpressionType::COMPARE_IN; - min_parameters = 2; - max_parameters = 10; - break; - case 1: - type = ExpressionType::COMPARE_NOT_IN; - min_parameters = 2; - max_parameters = 10; - break; - case 2: - type = ExpressionType::OPERATOR_NOT; - min_parameters = 1; - max_parameters = 1; - break; - case 3: - type = ExpressionType::OPERATOR_COALESCE; - min_parameters = 2; - max_parameters = 10; - break; - case 4: - type = ExpressionType::OPERATOR_IS_NULL; - min_parameters = 1; - max_parameters = 1; - break; - case 5: - type = ExpressionType::OPERATOR_IS_NOT_NULL; - min_parameters = 1; - max_parameters = 1; - break; - case 6: - type = ExpressionType::ARRAY_EXTRACT; - min_parameters = 2; - max_parameters = 2; - break; - case 7: - type = ExpressionType::ARRAY_SLICE; - min_parameters = 3; - max_parameters = 3; - break; - case 8: - type = ExpressionType::ARRAY_CONSTRUCTOR; - min_parameters = 0; - max_parameters = 10; - break; - default: - throw InternalException("StatementGenerator::GenerateOperator"); - } - auto children = GenerateChildren(min_parameters, max_parameters); - return make_uniq(type, std::move(children)); -} - -vector> StatementGenerator::GenerateChildren(idx_t min, idx_t max) { - if (min > max) { - throw InternalException("StatementGenerator::GenerateChildren min > max"); - } - vector> children; - if (min == 0 && max == 0) { - return children; - } - idx_t upper_bound = min == max ? min : min + RandomValue(max - min); - for (idx_t i = 0; i < upper_bound; i++) { - children.push_back(GenerateExpression()); - } - return children; -} - -class WindowChecker { -public: - explicit WindowChecker(StatementGenerator &generator) : generator(generator) { - generator.in_window = true; - } - ~WindowChecker() { - generator.in_window = false; - } - - StatementGenerator &generator; -}; - -unique_ptr StatementGenerator::GenerateWindowFunction(optional_ptr function) { - if (in_window) { - // we cannot nest window functions - return GenerateColumnRef(); - } - ExpressionType type; - string name; - idx_t min_parameters; - idx_t max_parameters; - if (function) { - type = ExpressionType::WINDOW_AGGREGATE; - name = function->name; - min_parameters = function->arguments.size(); - max_parameters = min_parameters; - } else { - name = Choose({"rank", "rank_dense", "percent_rank", "row_number", "first_value", "last_value", - "nth_value", "cume_dist", "lead", "lag", "ntile"}); - type = WindowExpression::WindowToExpressionType(name); - switch (type) { - case ExpressionType::WINDOW_RANK: - case ExpressionType::WINDOW_RANK_DENSE: - case ExpressionType::WINDOW_ROW_NUMBER: - case ExpressionType::WINDOW_PERCENT_RANK: - case ExpressionType::WINDOW_CUME_DIST: - min_parameters = 0; - break; - case ExpressionType::WINDOW_NTILE: - case ExpressionType::WINDOW_FIRST_VALUE: - case ExpressionType::WINDOW_LAST_VALUE: - case ExpressionType::WINDOW_LEAD: - case ExpressionType::WINDOW_LAG: - min_parameters = 1; - break; - case ExpressionType::WINDOW_NTH_VALUE: - min_parameters = 2; - break; - default: - throw InternalException("StatementGenerator::GenerateWindow"); - } - max_parameters = min_parameters; - } - WindowChecker checker(*this); - auto result = make_uniq(type, INVALID_CATALOG, INVALID_SCHEMA, std::move(name)); - result->children = GenerateChildren(min_parameters, max_parameters); - while (RandomPercentage(50)) { - result->partitions.push_back(GenerateExpression()); - } - if (RandomPercentage(30)) { - result->orders = std::move(GenerateOrderBy()->orders); - } - if (function) { - result->filter_expr = RandomExpression(30); - if (RandomPercentage(30)) { - result->ignore_nulls = true; - } - } - vector window_boundaries { - WindowBoundary::UNBOUNDED_PRECEDING, WindowBoundary::UNBOUNDED_FOLLOWING, WindowBoundary::CURRENT_ROW_RANGE, - WindowBoundary::CURRENT_ROW_ROWS, WindowBoundary::EXPR_PRECEDING_ROWS, WindowBoundary::EXPR_FOLLOWING_ROWS, - WindowBoundary::EXPR_PRECEDING_RANGE, WindowBoundary::EXPR_FOLLOWING_RANGE}; - do { - result->start = Choose(window_boundaries); - } while (result->start == WindowBoundary::UNBOUNDED_FOLLOWING); - do { - result->end = Choose(window_boundaries); - } while (result->end == WindowBoundary::UNBOUNDED_PRECEDING); - switch (result->start) { - case WindowBoundary::EXPR_PRECEDING_ROWS: - case WindowBoundary::EXPR_PRECEDING_RANGE: - case WindowBoundary::EXPR_FOLLOWING_ROWS: - case WindowBoundary::EXPR_FOLLOWING_RANGE: - result->start_expr = GenerateExpression(); - break; - default: - break; - } - switch (result->end) { - case WindowBoundary::EXPR_PRECEDING_ROWS: - case WindowBoundary::EXPR_PRECEDING_RANGE: - case WindowBoundary::EXPR_FOLLOWING_ROWS: - case WindowBoundary::EXPR_FOLLOWING_RANGE: - result->end_expr = GenerateExpression(); - break; - default: - break; - } - switch (type) { - case ExpressionType::WINDOW_LEAD: - case ExpressionType::WINDOW_LAG: - result->offset_expr = RandomExpression(30); - result->default_expr = RandomExpression(30); - break; - default: - break; - } - return std::move(result); -} - -unique_ptr StatementGenerator::RandomExpression(idx_t percentage) { - if (RandomPercentage(percentage)) { - return GenerateExpression(); - } - return nullptr; -} - -unique_ptr StatementGenerator::GenerateConjunction() { - auto left = GenerateExpression(); - auto right = GenerateExpression(); - ExpressionType conjunction_type; - switch (RandomValue(2)) { - case 0: - conjunction_type = ExpressionType::CONJUNCTION_AND; - break; - case 1: - conjunction_type = ExpressionType::CONJUNCTION_OR; - break; - default: - throw InternalException("StatementGenerator::GenerateConjunction"); - } - return make_uniq(conjunction_type, std::move(left), std::move(right)); -} - -unique_ptr StatementGenerator::GenerateStar() { - auto result = make_uniq(); - if (!current_relation_names.empty()) { - if (RandomPercentage(10)) { - result->relation_name = GenerateRelationName(); - } - } - - while (RandomPercentage(20)) { - auto column_name = GenerateColumnName(); - if (column_name.empty()) { - break; - } - result->exclude_list.insert(column_name); - } - while (RandomPercentage(20)) { - auto column_name = GenerateColumnName(); - if (column_name.empty()) { - break; - } - result->replace_list.insert(make_pair(column_name, GenerateExpression())); - } - if (RandomPercentage(50) || expression_depth > 0) { - result->columns = true; - if (RandomPercentage(50)) { - result->expr = GenerateLambda(); - } - } - return std::move(result); -} - -unique_ptr StatementGenerator::GenerateLambda() { - // generate the lambda name and add the lambda column names to the set of possibly-generated column names - auto lambda_parameter = GenerateIdentifier(); - // generate the lhs - auto lhs = make_uniq(lambda_parameter); - auto rhs = GenerateExpression(); - current_column_names.erase(std::find(current_column_names.begin(), current_column_names.end(), lambda_parameter)); - - return make_uniq(std::move(lhs), std::move(rhs)); -} - -string StatementGenerator::GenerateTableIdentifier() { - auto identifier = "t" + to_string(GetIndex()); - current_relation_names.push_back(identifier); - return identifier; -} - -string StatementGenerator::GenerateIdentifier() { - auto identifier = "c" + to_string(GetIndex()); - current_column_names.push_back(identifier); - return identifier; -} - -string StatementGenerator::GenerateSchemaIdentifier() { - auto identifier = "s" + to_string(GetIndex()); - // TODO: add support for current_schema_names - return identifier; -} - -string StatementGenerator::GenerateViewIdentifier() { - auto identifier = "v" + to_string(GetIndex()); - current_relation_names.push_back(identifier); - return identifier; -} - -idx_t StatementGenerator::GetIndex() { - if (parent) { - return parent->GetIndex(); - } - return ++index; -} - -unique_ptr StatementGenerator::GenerateSubquery() { - if (depth >= MAX_DEPTH || in_window) { - return GenerateConstant(); - } - auto subquery = make_uniq(); - - { - StatementGenerator child_generator(*this); - subquery->subquery = unique_ptr_cast(child_generator.GenerateSelect()); - } - subquery->subquery_type = - Choose({SubqueryType::ANY, SubqueryType::EXISTS, SubqueryType::SCALAR, SubqueryType::NOT_EXISTS}); - if (subquery->subquery_type == SubqueryType::ANY || subquery->subquery_type == SubqueryType::SCALAR) { - subquery->child = GenerateExpression(); - } - if (subquery->subquery_type == SubqueryType::ANY) { - subquery->comparison_type = GenerateComparisonType(); - } - return std::move(subquery); -} - -unique_ptr StatementGenerator::GenerateCast() { - auto child = GenerateExpression(); - auto type = GenerateLogicalType(); - return make_uniq(std::move(type), std::move(child), RandomBoolean()); -} - -unique_ptr StatementGenerator::GenerateBetween() { - auto input = GenerateExpression(); - auto lower = GenerateExpression(); - auto upper = GenerateExpression(); - return make_uniq(std::move(input), std::move(lower), std::move(upper)); -} - -ExpressionType StatementGenerator::GenerateComparisonType() { - static vector comparisons {ExpressionType::COMPARE_EQUAL, - ExpressionType::COMPARE_NOTEQUAL, - ExpressionType::COMPARE_LESSTHAN, - ExpressionType::COMPARE_GREATERTHAN, - ExpressionType::COMPARE_LESSTHANOREQUALTO, - ExpressionType::COMPARE_GREATERTHANOREQUALTO, - ExpressionType::COMPARE_DISTINCT_FROM, - ExpressionType::COMPARE_NOT_DISTINCT_FROM}; - return Choose(comparisons); -} - -unique_ptr StatementGenerator::GenerateComparison() { - auto lhs = GenerateExpression(); - auto rhs = GenerateExpression(); - return make_uniq(GenerateComparisonType(), std::move(lhs), std::move(rhs)); -} - -unique_ptr StatementGenerator::GeneratePositionalReference() { - return make_uniq(1 + RandomValue(10)); -} - -unique_ptr StatementGenerator::GenerateCase() { - auto case_stmt = make_uniq(); - case_stmt->else_expr = GenerateExpression(); - while (true) { - CaseCheck check; - check.then_expr = GenerateExpression(); - check.when_expr = GenerateExpression(); - case_stmt->case_checks.push_back(std::move(check)); - if (RandomPercentage(50)) { - break; - } - } - return std::move(case_stmt); -} - -//===--------------------------------------------------------------------===// -// Helpers -//===--------------------------------------------------------------------===// -string StatementGenerator::GenerateRelationName() { - if (parent) { - auto parent_relation = parent->GenerateRelationName(); - if (current_relation_names.empty()) { - return parent_relation; - } - if (parent_relation.empty() || RandomPercentage(80)) { - return Choose(current_relation_names); - } - return parent_relation; - } else { - if (current_relation_names.empty()) { - return string(); - } - return Choose(current_relation_names); - } -} - -string StatementGenerator::GenerateColumnName() { - if (parent) { - auto parent_column = parent->GenerateColumnName(); - if (current_column_names.empty()) { - return parent_column; - } - if (parent_column.empty() || RandomPercentage(80)) { - return Choose(current_column_names); - } - return parent_column; - } else { - if (current_column_names.empty()) { - return string(); - } - return Choose(current_column_names); - } -} - -idx_t StatementGenerator::RandomValue(idx_t max) { - if (max == 0) { - return 0; - } - return RandomEngine::Get(context).NextRandomInteger() % max; -} - -string StatementGenerator::RandomString(idx_t length) { - - const string charset = "$_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; - string result = ""; - for (int i = 0; i < length; ++i) { - int randomIndex = RandomValue(charset.length()); - result += charset[randomIndex]; - } - - return result; -} - -bool StatementGenerator::RandomBoolean() { - return RandomValue(2) == 0; -} - -bool StatementGenerator::RandomPercentage(idx_t percentage) { - if (percentage > 100) { - return true; - } - return RandomValue(100) <= percentage; -} - -//===--------------------------------------------------------------------===// -// Exhaustive Function Generation -//===--------------------------------------------------------------------===// -bool StatementGenerator::FunctionArgumentsAlwaysNull(const string &name) { - // some functions run for a very long time with extreme parameters because they e.g. generate giant strings - // for that reason we skip testing those functions with extreme parameters - static case_insensitive_set_t always_null_functions {"rpad", "pad", "lpad", "repeat"}; - - return always_null_functions.find(name) != always_null_functions.end(); -} -string StatementGenerator::GenerateTestAllTypes(BaseScalarFunction &base_function) { - auto select = make_uniq(); - auto node = make_uniq(); - - bool always_null = FunctionArgumentsAlwaysNull(base_function.name); - - vector> children; - for (auto &arg : base_function.arguments) { - // look up the type - unique_ptr argument; - if (!always_null) { - for (auto &test_type : generator_context->test_types) { - if (test_type.type.id() == arg.id()) { - argument = make_uniq(test_type.name); - } - } - } - if (!argument) { - argument = make_uniq(Value(arg)); - } - children.push_back(std::move(argument)); - } - auto from_clause = make_uniq(); - from_clause->table_name = "all_types"; - node->from_table = std::move(from_clause); - - auto function_expr = make_uniq(base_function.name, std::move(children)); - node->select_list.push_back(std::move(function_expr)); - - select->node = std::move(node); - return select->ToString(); -} - -string StatementGenerator::GenerateTestVectorTypes(BaseScalarFunction &base_function) { - auto select = make_uniq(); - auto node = make_uniq(); - - bool always_null = FunctionArgumentsAlwaysNull(base_function.name); - - vector> children; - vector> test_vector_types; - vector column_aliases; - for (auto &arg : base_function.arguments) { - unique_ptr argument; - if (!always_null) { - string argument_name = "c" + to_string(column_aliases.size() + 1); - column_aliases.push_back(argument_name); - argument = make_uniq(std::move(argument_name)); - auto constant_expr = make_uniq(Value()); - auto cast = make_uniq(arg, std::move(constant_expr)); - test_vector_types.push_back(std::move(cast)); - } else { - argument = make_uniq(Value(arg)); - } - children.push_back(std::move(argument)); - } - auto from_clause = make_uniq(); - auto vector_types_fun = make_uniq("test_vector_types", std::move(test_vector_types)); - from_clause->function = std::move(vector_types_fun); - from_clause->alias = "test_vector_types"; - from_clause->column_name_alias = std::move(column_aliases); - node->from_table = std::move(from_clause); - - auto function_expr = make_uniq(base_function.name, std::move(children)); - node->select_list.push_back(std::move(function_expr)); - - select->node = std::move(node); - return select->ToString(); -} - -string StatementGenerator::GenerateCast(const LogicalType &target, const string &source_name, bool add_varchar) { - auto select = make_uniq(); - auto node = make_uniq(); - - auto from_clause = make_uniq(); - from_clause->table_name = "all_types"; - node->from_table = std::move(from_clause); - - unique_ptr source; - source = make_uniq(source_name); - if (add_varchar) { - source = make_uniq(LogicalType::VARCHAR, std::move(source)); - } - auto cast = make_uniq(target, std::move(source)); - node->select_list.push_back(std::move(cast)); - - select->node = std::move(node); - return select->ToString(); -} - -void StatementGenerator::GenerateAllScalar(ScalarFunctionCatalogEntry &scalar_function, vector &result) { - for (idx_t offset = 0; offset < scalar_function.functions.Size(); offset++) { - auto function = scalar_function.functions.GetFunctionByOffset(offset); - - result.push_back(GenerateTestAllTypes(function)); - result.push_back(GenerateTestVectorTypes(function)); - } -} - -void StatementGenerator::GenerateAllAggregate(AggregateFunctionCatalogEntry &aggregate_function, - vector &result) { - for (idx_t offset = 0; offset < aggregate_function.functions.Size(); offset++) { - auto function = aggregate_function.functions.GetFunctionByOffset(offset); - - result.push_back(GenerateTestAllTypes(function)); - result.push_back(GenerateTestVectorTypes(function)); - } -} - -vector StatementGenerator::GenerateAllFunctionCalls() { - // all scalar functions - vector result; - for (auto &function_ref : generator_context->scalar_functions) { - auto &function = function_ref.get(); - switch (function.type) { - case CatalogType::SCALAR_FUNCTION_ENTRY: { - auto &scalar_entry = function.Cast(); - GenerateAllScalar(scalar_entry, result); - break; - } - case CatalogType::AGGREGATE_FUNCTION_ENTRY: { - auto &aggregate_entry = function.Cast(); - GenerateAllAggregate(aggregate_entry, result); - break; - } - case CatalogType::MACRO_ENTRY: - default: - break; - } - } - // generate all casts - for (auto &source_type : generator_context->test_types) { - for (auto &target_type : generator_context->test_types) { - result.push_back(GenerateCast(target_type.type, source_type.name, false)); - result.push_back(GenerateCast(target_type.type, source_type.name, true)); - } - } - return result; -} - -} // namespace duckdb diff --git a/extension/sqlsmith/statement_simplifier.cpp b/extension/sqlsmith/statement_simplifier.cpp deleted file mode 100644 index 66662f4cc02..00000000000 --- a/extension/sqlsmith/statement_simplifier.cpp +++ /dev/null @@ -1,453 +0,0 @@ -#include "statement_simplifier.hpp" - -#ifndef DUCKDB_AMALGAMATION -#include "duckdb/parser/query_node/select_node.hpp" -#include "duckdb/parser/query_node/set_operation_node.hpp" -#include "duckdb/parser/tableref/list.hpp" -#include "duckdb/parser/parsed_expression_iterator.hpp" -#include "duckdb/parser/expression/list.hpp" -#include "duckdb/parser/statement/delete_statement.hpp" -#include "duckdb/parser/statement/insert_statement.hpp" -#include "duckdb/parser/statement/update_statement.hpp" -#include "duckdb/parser/statement/select_statement.hpp" -#endif - -namespace duckdb { - -StatementSimplifier::StatementSimplifier(SQLStatement &statement_p, vector &result_p) - : statement(statement_p), result(result_p) { -} - -void StatementSimplifier::Simplification() { - result.push_back(statement.ToString()); -} - -template -void StatementSimplifier::SimplifyReplace(T &element, T &other) { - auto n = std::move(element); - element = std::move(other); - Simplification(); - other = std::move(element); - element = std::move(n); -} - -template -void StatementSimplifier::SimplifyList(vector &list, bool is_optional) { - if (list.size() <= (is_optional ? 0 : 1)) { - return; - } - for (idx_t i = 0; i < list.size(); i++) { - auto n = std::move(list[i]); - list.erase(list.begin() + i); - Simplification(); - list.insert(list.begin() + i, std::move(n)); - } -} - -template -void StatementSimplifier::SimplifyMap(T &map) { - if (map.empty()) { - return; - } - // copy the keys - vector keys; - for (auto &entry : map) { - keys.push_back(entry.first); - } - // try to remove all of the keys - for (idx_t i = 0; i < keys.size(); i++) { - auto entry = map.find(keys[i]); - auto n = std::move(entry->second); - map.erase(entry); - Simplification(); - map.insert(make_pair(std::move(keys[i]), std::move(n))); - } -} - -template -void StatementSimplifier::SimplifySet(T &set) { - if (set.empty()) { - return; - } - // copy the keys - vector keys; - for (auto &entry : set) { - keys.push_back(entry); - } - // try to remove all of the keys - for (idx_t i = 0; i < keys.size(); i++) { - auto entry = set.find(keys[i]); - set.erase(entry); - Simplification(); - set.insert(std::move(keys[i])); - } -} - -template -void StatementSimplifier::SimplifyOptional(duckdb::unique_ptr &opt) { - if (!opt) { - return; - } - auto n = std::move(opt); - Simplification(); - opt = std::move(n); -} - -template -void StatementSimplifier::SimplifyEnum(T &enum_ref, T default_value) { - if (enum_ref == default_value) { - return; - } - auto current = enum_ref; - enum_ref = default_value; - Simplification(); - enum_ref = current; -} - -template -void StatementSimplifier::SimplifyAlias(T &input) { - auto alias = std::move(input.alias); - auto column_name_alias = std::move(input.column_name_alias); - Simplification(); - input.alias = std::move(alias); - input.column_name_alias = std::move(column_name_alias); -} - -void StatementSimplifier::Simplify(unique_ptr &ref) { - switch (ref->type) { - case TableReferenceType::SUBQUERY: { - auto &subquery = ref->Cast(); - SimplifyAlias(subquery); - if (subquery.subquery->node->type == QueryNodeType::SELECT_NODE) { - auto &select_node = subquery.subquery->node->Cast(); - SimplifyReplace(ref, select_node.from_table); - } - Simplify(subquery.subquery->node); - break; - } - case TableReferenceType::JOIN: { - auto &cp = ref->Cast(); - Simplify(cp.left); - Simplify(cp.right); - SimplifyOptionalExpression(cp.condition); - SimplifyReplace(ref, cp.left); - SimplifyReplace(ref, cp.right); - SimplifyEnum(cp.type, JoinType::INNER); - SimplifyEnum(cp.ref_type, JoinRefType::REGULAR); - break; - } - case TableReferenceType::EXPRESSION_LIST: { - auto &expr_list = ref->Cast(); - if (expr_list.values.size() == 1) { - SimplifyList(expr_list.values[0]); - } else if (expr_list.values.size() > 1) { - SimplifyList(expr_list.values, false); - } - break; - } - case TableReferenceType::TABLE_FUNCTION: { - auto &table_function = ref->Cast(); - // try to remove aliases - SimplifyAlias(table_function); - break; - } - case TableReferenceType::BASE_TABLE: { - auto &table_ref = ref->Cast(); - SimplifyAlias(table_ref); - break; - } - default: - break; - } -} - -void StatementSimplifier::Simplify(GroupByNode &groups) { - // try to remove all groups - auto group_expr = std::move(groups.group_expressions); - auto group_sets = std::move(groups.grouping_sets); - Simplification(); - groups.group_expressions = std::move(group_expr); - groups.grouping_sets = std::move(group_sets); - - // try to remove grouping sets - SimplifyList(groups.grouping_sets, false); - // simplify expressions - for (auto &group : groups.group_expressions) { - SimplifyExpression(group); - } -} - -void StatementSimplifier::Simplify(SelectNode &node) { - // simplify projection list - SimplifyExpressionList(node.select_list, false); - // from clause - SimplifyOptional(node.from_table); - // simplify groups - Simplify(node.groups); - // simplify filters - SimplifyOptionalExpression(node.where_clause); - SimplifyOptionalExpression(node.having); - SimplifyOptionalExpression(node.qualify); - SimplifyOptional(node.sample); - SimplifyEnum(node.aggregate_handling, AggregateHandling::STANDARD_HANDLING); - - Simplify(node.from_table); -} - -void StatementSimplifier::Simplify(SetOperationNode &node) { - Simplify(node.left); - Simplify(node.right); -} - -void StatementSimplifier::Simplify(CommonTableExpressionMap &cte) { - // remove individual CTEs - SimplifyMap(cte.map); - for (auto &cte_child : cte.map) { - // simplify individual ctes - Simplify(cte_child.second->query->node); - } -} - -void StatementSimplifier::Simplify(unique_ptr &node) { - query_nodes.push_back(node); - Simplify(node->cte_map); - switch (node->type) { - case QueryNodeType::SELECT_NODE: - Simplify(node->Cast()); - break; - case QueryNodeType::SET_OPERATION_NODE: { - auto &setop = node->Cast(); - SimplifyReplace(node, setop.left); - SimplifyReplace(node, setop.right); - Simplify(setop); - break; - } - case QueryNodeType::RECURSIVE_CTE_NODE: - case QueryNodeType::CTE_NODE: - default: - break; - } - for (auto &modifier : node->modifiers) { - Simplify(*modifier); - } - SimplifyList(node->modifiers); - query_nodes.pop_back(); -} - -void StatementSimplifier::SimplifyExpressionList(duckdb::unique_ptr &expr, - vector> &expression_list) { - for (auto &child : expression_list) { - SimplifyChildExpression(expr, child); - } -} - -void StatementSimplifier::SimplifyExpressionList(vector> &expression_list, - bool is_optional) { - SimplifyList(expression_list, is_optional); - for (auto &child : expression_list) { - SimplifyExpression(child); - } -} - -void StatementSimplifier::SimplifyChildExpression(duckdb::unique_ptr &expr, - unique_ptr &child) { - if (!child) { - return; - } - SimplifyReplace(expr, child); - SimplifyExpression(child); -} - -void StatementSimplifier::SimplifyOptionalExpression(duckdb::unique_ptr &expr) { - if (!expr) { - return; - } - SimplifyOptional(expr); - SimplifyExpression(expr); -} - -void StatementSimplifier::SimplifyExpression(duckdb::unique_ptr &expr) { - if (!expr) { - return; - } - auto expr_class = expr->GetExpressionClass(); - switch (expr_class) { - case ExpressionClass::CONSTANT: - return; - default: - break; - } - duckdb::unique_ptr constant = make_uniq(Value()); - SimplifyReplace(expr, constant); - switch (expr_class) { - case ExpressionClass::CONJUNCTION: { - auto &conj = expr->Cast(); - SimplifyExpressionList(expr, conj.children); - break; - } - case ExpressionClass::FUNCTION: { - auto &func = expr->Cast(); - SimplifyExpressionList(expr, func.children); - SimplifyEnum(func.distinct, false); - SimplifyOptionalExpression(func.filter); - SimplifyOptional(func.order_bys); - if (func.order_bys) { - Simplify(*func.order_bys); - } - break; - } - case ExpressionClass::OPERATOR: { - auto &op = expr->Cast(); - SimplifyExpressionList(expr, op.children); - break; - } - case ExpressionClass::CASE: { - auto &op = expr->Cast(); - SimplifyChildExpression(expr, op.else_expr); - for (auto &case_check : op.case_checks) { - SimplifyChildExpression(expr, case_check.then_expr); - SimplifyChildExpression(expr, case_check.when_expr); - } - break; - } - case ExpressionClass::CAST: { - auto &cast = expr->Cast(); - SimplifyChildExpression(expr, cast.child); - break; - } - case ExpressionClass::COLLATE: { - auto &collate = expr->Cast(); - SimplifyChildExpression(expr, collate.child); - break; - } - case ExpressionClass::SUBQUERY: { - auto &subq = expr->Cast(); - // try to move this subquery fully into the outer query - if (!query_nodes.empty()) { - SimplifyReplace(query_nodes.back().get(), subq.subquery->node); - } - SimplifyChildExpression(expr, subq.child); - Simplify(subq.subquery->node); - break; - } - case ExpressionClass::COMPARISON: { - auto &comp = expr->Cast(); - SimplifyChildExpression(expr, comp.left); - SimplifyChildExpression(expr, comp.right); - break; - } - case ExpressionClass::STAR: { - auto &star = expr->Cast(); - SimplifyMap(star.replace_list); - SimplifySet(star.exclude_list); - for (auto &entry : star.replace_list) { - SimplifyChildExpression(expr, entry.second); - } - break; - } - case ExpressionClass::WINDOW: { - auto &window = expr->Cast(); - SimplifyExpressionList(expr, window.children); - SimplifyExpressionList(expr, window.partitions); - SimplifyList(window.orders); - SimplifyChildExpression(expr, window.filter_expr); - SimplifyChildExpression(expr, window.start_expr); - SimplifyChildExpression(expr, window.end_expr); - SimplifyChildExpression(expr, window.offset_expr); - SimplifyChildExpression(expr, window.default_expr); - SimplifyEnum(window.ignore_nulls, false); - SimplifyEnum(window.distinct, false); - SimplifyEnum(window.start, WindowBoundary::UNBOUNDED_PRECEDING); - SimplifyEnum(window.end, WindowBoundary::CURRENT_ROW_RANGE); - SimplifyEnum(window.exclude_clause, WindowExcludeMode::NO_OTHER); - break; - } - default: - break; - } -} - -void StatementSimplifier::Simplify(ResultModifier &modifier) { - switch (modifier.type) { - case ResultModifierType::ORDER_MODIFIER: - Simplify(modifier.Cast()); - break; - default: - break; - } -} - -void StatementSimplifier::Simplify(OrderModifier &modifier) { - for (auto &order : modifier.orders) { - SimplifyExpression(order.expression); - } - SimplifyList(modifier.orders); -} - -void StatementSimplifier::Simplify(SelectStatement &stmt) { - Simplify(stmt.node); - ParsedExpressionIterator::EnumerateQueryNodeChildren( - *stmt.node, [&](duckdb::unique_ptr &child) { SimplifyExpression(child); }); -} - -void StatementSimplifier::Simplify(InsertStatement &stmt) { - Simplify(stmt.cte_map); - Simplify(*stmt.select_statement); - SimplifyList(stmt.returning_list); -} - -void StatementSimplifier::Simplify(DeleteStatement &stmt) { - Simplify(stmt.cte_map); - SimplifyOptional(stmt.condition); - SimplifyExpression(stmt.condition); - SimplifyList(stmt.using_clauses); - SimplifyList(stmt.returning_list); -} - -void StatementSimplifier::Simplify(UpdateSetInfo &info) { - SimplifyOptional(info.condition); - SimplifyExpression(info.condition); - if (info.columns.size() > 1) { - for (idx_t i = 0; i < info.columns.size(); i++) { - auto col = std::move(info.columns[i]); - auto expr = std::move(info.expressions[i]); - info.columns.erase(info.columns.begin() + i); - info.expressions.erase(info.expressions.begin() + i); - Simplification(); - info.columns.insert(info.columns.begin() + i, std::move(col)); - info.expressions.insert(info.expressions.begin() + i, std::move(expr)); - } - } - for (auto &expr : info.expressions) { - SimplifyExpression(expr); - } -} - -void StatementSimplifier::Simplify(UpdateStatement &stmt) { - Simplify(stmt.cte_map); - SimplifyOptional(stmt.from_table); - D_ASSERT(stmt.set_info); - Simplify(*stmt.set_info); - SimplifyList(stmt.returning_list); -} - -void StatementSimplifier::Simplify(SQLStatement &stmt) { - switch (stmt.type) { - case StatementType::SELECT_STATEMENT: - Simplify(stmt.Cast()); - break; - case StatementType::INSERT_STATEMENT: - Simplify(stmt.Cast()); - break; - case StatementType::UPDATE_STATEMENT: - Simplify(stmt.Cast()); - break; - case StatementType::DELETE_STATEMENT: - Simplify(stmt.Cast()); - break; - default: - throw InvalidInputException("Expected a single SELECT, INSERT or UPDATE statement"); - } -} - -} // namespace duckdb diff --git a/extension/sqlsmith/third_party/CMakeLists.txt b/extension/sqlsmith/third_party/CMakeLists.txt deleted file mode 100644 index 2dcdc609415..00000000000 --- a/extension/sqlsmith/third_party/CMakeLists.txt +++ /dev/null @@ -1,5 +0,0 @@ -add_subdirectory(sqlsmith) - -set(SQLSMITH_OBJECT_FILES - ${SQLSMITH_OBJECT_FILES} - PARENT_SCOPE) diff --git a/extension/sqlsmith/third_party/sqlsmith/CMakeLists.txt b/extension/sqlsmith/third_party/sqlsmith/CMakeLists.txt deleted file mode 100644 index 4970d898b39..00000000000 --- a/extension/sqlsmith/third_party/sqlsmith/CMakeLists.txt +++ /dev/null @@ -1,20 +0,0 @@ -include_directories(include) - -add_library( - sqlsmith OBJECT - duckdb.cc - dump.cc - expr.cc - grammar.cc - impedance.cc - log.cc - prod.cc - random.cc - relmodel.cc - schema.cc - sqlsmith.cc) -set(SQLSMITH_OBJECT_FILES - ${SQLSMITH_OBJECT_FILES} $ - PARENT_SCOPE) - -disable_target_warnings(sqlsmith) diff --git a/extension/sqlsmith/third_party/sqlsmith/duckdb.cc b/extension/sqlsmith/third_party/sqlsmith/duckdb.cc deleted file mode 100644 index 03687d9c7ef..00000000000 --- a/extension/sqlsmith/third_party/sqlsmith/duckdb.cc +++ /dev/null @@ -1,177 +0,0 @@ -#include "duckdb.hh" - -#include -#include -#include -#include -#include -#include - -#include - -using namespace duckdb; -using namespace std; - -static regex e_syntax(".*syntax error at or near .*"); -static regex e_internal(".*INTERNAL.*"); - -sqlsmith_duckdb_connection::sqlsmith_duckdb_connection(duckdb::DatabaseInstance &database) { - // in-memory database - connection = make_uniq(database); -} - -void sqlsmith_duckdb_connection::q(const char *query) { - auto result = connection->Query(query); - if (result->HasError()) { - result->ThrowError(); - } -} - -schema_duckdb::schema_duckdb(duckdb::DatabaseInstance &database, bool no_catalog, bool verbose_output) - : sqlsmith_duckdb_connection(database) { - // generate empty TPC-H schema - if (verbose_output) - cerr << "Loading tables..."; - auto result = connection->Query("SELECT * FROM sqlite_master WHERE type IN ('table', 'view')"); - if (result->HasError()) { - result->ThrowError(); - } - for (size_t i = 0; i < result->RowCount(); i++) { - auto type = StringValue::Get(result->GetValue(0, i)); - auto name = StringValue::Get(result->GetValue(2, i)); - bool view = type == "view"; - table tab(name, "main", !view, !view); - tables.push_back(tab); - } - if (verbose_output) - cerr << "done." << endl; - - if (tables.size() == 0) { - throw std::runtime_error("No tables available in catalog!"); - } - if (verbose_output) - cerr << "Loading columns and constraints..."; - - for (auto t = tables.begin(); t != tables.end(); ++t) { - result = connection->Query("PRAGMA table_info('" + t->name + "')"); - if (result->HasError()) { - result->ThrowError(); - } - for (size_t i = 0; i < result->RowCount(); i++) { - auto name = StringValue::Get(result->GetValue(1, i)); - auto type = StringValue::Get(result->GetValue(2, i)); - column c(name, sqltype::get(type)); - t->columns().push_back(c); - } - } - - if (verbose_output) - cerr << "done." << endl; - - Connection con(database); - auto query_result = con.Query(R"( -SELECT function_name, parameter_types, return_type, function_type -FROM duckdb_functions() -WHERE NOT(has_side_effects) - AND (function_type='aggregate' or function_type='scalar'); - )"); - - for (auto &row : *query_result) { - auto function_name = row.GetValue(0); - auto parameter_types = row.GetValue(1); - auto return_type = row.GetValue(2); - auto function_type = row.GetValue(3); - auto ¶ms = ListValue::GetChildren(parameter_types); - if (function_type == "scalar") { - // check if this is an operator or a function - bool is_operator = false; - for (auto ch : function_name) { - if (!StringUtil::CharacterIsAlpha(ch) && !StringUtil::CharacterIsDigit(ch) && ch != '_') { - is_operator = true; - break; - } - } - if (is_operator) { - // operator - if (params.size() == 2) { - auto lparam = StringValue::Get(params[0]); - auto rparam = StringValue::Get(params[1]); - op o(function_name, sqltype::get(lparam), sqltype::get(rparam), sqltype::get(return_type)); - register_operator(o); - } - } else { - // function - routine proc("", "", sqltype::get(return_type), function_name); - for (auto ¶m : params) { - auto param_name = StringValue::Get(params[0]); - proc.argtypes.push_back(sqltype::get(param_name)); - } - register_routine(proc); - } - } else if (function_type == "aggregate") { - routine proc("", "", sqltype::get(return_type), function_name); - for (auto ¶m : params) { - auto param_name = StringValue::Get(params[0]); - proc.argtypes.push_back(sqltype::get(param_name)); - } - register_aggregate(proc); - } else { - throw std::runtime_error("unrecognized function type in sqlsmith"); - } - } - - booltype = sqltype::get("BOOLEAN"); - inttype = sqltype::get("INTEGER"); - - internaltype = sqltype::get("internal"); - arraytype = sqltype::get("ARRAY"); - - true_literal = "1"; - false_literal = "0"; - - auto &type_list = sqltype::get_types(); - for (auto &kv : type_list) { - types.push_back(kv.second); - } - - generate_indexes(verbose_output); -} - -dut_duckdb::dut_duckdb(duckdb::DatabaseInstance &database) : sqlsmith_duckdb_connection(database) { -} - -volatile bool is_active = false; -// timeout is 10ms * TIMEOUT_TICKS -#define TIMEOUT_TICKS 50 - -void sleep_thread(Connection *connection) { - for (size_t i = 0; i < TIMEOUT_TICKS && is_active; i++) { - std::this_thread::sleep_for(std::chrono::milliseconds(10)); - } - if (is_active) { - connection->Interrupt(); - } -} - -void dut_duckdb::test(const std::string &stmt) { - is_active = true; - thread interrupt_thread(sleep_thread, connection.get()); - auto result = connection->Query(stmt); - is_active = false; - interrupt_thread.join(); - - if (result->HasError()) { - auto error = result->GetError().c_str(); - if (regex_match(error, e_internal)) { - throw dut::broken(error); - } - try { - if (regex_match(error, e_syntax)) - throw dut::syntax(error); - else - throw dut::failure(error); - } catch (dut::failure &e) { - throw; - } - } -} diff --git a/extension/sqlsmith/third_party/sqlsmith/dump.cc b/extension/sqlsmith/third_party/sqlsmith/dump.cc deleted file mode 100644 index 0c43bd1e613..00000000000 --- a/extension/sqlsmith/third_party/sqlsmith/dump.cc +++ /dev/null @@ -1,60 +0,0 @@ -#include -#include - -#include "dump.hh" -#include "util.hh" - -using namespace std; - -std::string graphml_dumper::id(struct prod *p) { - ostringstream os; - os << pretty_type(p) << "_" << p; - return os.str(); -} - -graphml_dumper::graphml_dumper(ostream &out) : o(out) { - o << "" << endl - << "" << endl; - - o << "" - << endl; - o << "" - << endl; - o << "" - << endl; - - o << "" << endl; -} - -void graphml_dumper::visit(struct prod *p) { - o << ""; - o << "" << p->retries << ""; - o << "" << pretty_type(p) << ""; - o << "" << p->scope << ""; - o << "" << endl; - if (p->pprod) { - o << "pprod) << "\"/>"; - } - o << endl; -} - -graphml_dumper::~graphml_dumper() { - o << "" << endl; -} - -void ast_logger::generated(prod &query) { - string filename(""); - filename += "sqlsmith-"; - filename += to_string(queries); - filename += ".xml"; - ofstream os(filename); - graphml_dumper visitor(os); - query.accept(&visitor); - queries++; -} diff --git a/extension/sqlsmith/third_party/sqlsmith/expr.cc b/extension/sqlsmith/third_party/sqlsmith/expr.cc deleted file mode 100644 index dc181ee20a8..00000000000 --- a/extension/sqlsmith/third_party/sqlsmith/expr.cc +++ /dev/null @@ -1,352 +0,0 @@ -#include -#include -#include -#include -#include - -#include "random.hh" -#include "relmodel.hh" -#include "grammar.hh" -#include "schema.hh" -#include "impedance.hh" -#include "expr.hh" - -using namespace std; -using impedance::matched; - -shared_ptr value_expr::factory(prod *p, sqltype *type_constraint) { - try { - if (1 == d20() && p->level < d6() && window_function::allowed(p)) - return std::make_shared(p, type_constraint); - else if (1 == d42() && p->level < d6()) - return std::make_shared(p, type_constraint); - else if (1 == d42() && p->level < d6()) - return std::make_shared(p, type_constraint); - else if (p->level < d6() && d6() == 1) - return std::make_shared(p, type_constraint); - else if (d12() == 1) - return std::make_shared(p, type_constraint); - else if (p->level < d6() && d9() == 1) - return std::make_shared(p, type_constraint); - else if (p->scope->refs.size() && d20() > 1) - return std::make_shared(p, type_constraint); - else - return std::make_shared(p, type_constraint); - } catch (runtime_error &e) { - } - p->retry(); - return factory(p, type_constraint); -} - -case_expr::case_expr(prod *p, sqltype *type_constraint) : value_expr(p) { - condition = bool_expr::factory(this); - true_expr = value_expr::factory(this, type_constraint); - false_expr = value_expr::factory(this, true_expr->type); - - if (false_expr->type != true_expr->type) { - /* Types are consistent but not identical. Try to find a more - concrete one for a better match. */ - if (true_expr->type->consistent(false_expr->type)) - true_expr = value_expr::factory(this, false_expr->type); - else - false_expr = value_expr::factory(this, true_expr->type); - } - type = true_expr->type; -} - -void case_expr::out(std::ostream &out) { - out << "case when " << *condition; - out << " then " << *true_expr; - out << " else " << *true_expr; - out << " end"; - indent(out); -} - -void case_expr::accept(prod_visitor *v) { - v->visit(this); - condition->accept(v); - true_expr->accept(v); - false_expr->accept(v); -} - -column_reference::column_reference(prod *p, sqltype *type_constraint) : value_expr(p) { - if (type_constraint) { - auto pairs = scope->refs_of_type(type_constraint); - auto picked = random_pick(pairs); - reference += picked.first->ident() + "." + picked.second.name; - type = picked.second.type; - assert(type_constraint->consistent(type)); - } else { - named_relation *r = random_pick(scope->refs); - - reference += r->ident() + "."; - column &c = random_pick(r->columns()); - type = c.type; - reference += c.name; - } -} - -shared_ptr bool_expr::factory(prod *p) { - try { - if (p->level > d100()) - return std::make_shared(p); - if (d6() < 4) - return std::make_shared(p); - else if (d6() < 4) - return std::make_shared(p); - else if (d6() < 4) - return std::make_shared(p); - else if (d6() < 4) - return std::make_shared(p); - else - return std::make_shared(p); - // return std::make_shared(q); - } catch (runtime_error &e) { - } - p->retry(); - return factory(p); -} - -exists_predicate::exists_predicate(prod *p) : bool_expr(p) { - subquery = std::make_shared(this, scope); -} - -void exists_predicate::accept(prod_visitor *v) { - v->visit(this); - subquery->accept(v); -} - -void exists_predicate::out(std::ostream &out) { - out << "EXISTS ("; - indent(out); - out << *subquery << ")"; -} - -distinct_pred::distinct_pred(prod *p) : bool_binop(p) { - lhs = std::make_shared(this); - rhs = std::make_shared(this, lhs->type); -} - -comparison_op::comparison_op(prod *p) : bool_binop(p) { - auto &idx = p->scope->schema->operators_returning_type; - - auto iters = idx.equal_range(scope->schema->booltype); - oper = random_pick<>(iters)->second; - - lhs = value_expr::factory(this, oper->left); - rhs = value_expr::factory(this, oper->right); - - if (oper->left == oper->right && lhs->type != rhs->type) { - - if (lhs->type->consistent(rhs->type)) - lhs = value_expr::factory(this, rhs->type); - else - rhs = value_expr::factory(this, lhs->type); - } -} - -coalesce::coalesce(prod *p, sqltype *type_constraint, const char *abbrev) : value_expr(p), abbrev_(abbrev) { - auto first_expr = value_expr::factory(this, type_constraint); - auto second_expr = value_expr::factory(this, first_expr->type); - - retry_limit = 20; - while (first_expr->type != second_expr->type) { - retry(); - if (first_expr->type->consistent(second_expr->type)) - first_expr = value_expr::factory(this, second_expr->type); - else - second_expr = value_expr::factory(this, first_expr->type); - } - type = second_expr->type; - - value_exprs.push_back(first_expr); - value_exprs.push_back(second_expr); -} - -void coalesce::out(std::ostream &out) { - out << "cast(" << abbrev_ << "("; - for (auto expr = value_exprs.begin(); expr != value_exprs.end(); expr++) { - out << **expr; - if (expr + 1 != value_exprs.end()) - out << ",", indent(out); - } - out << ")"; - out << " as " << type->name << ")"; -} - -const_expr::const_expr(prod *p, sqltype *type_constraint) : value_expr(p), expr("") { - type = type_constraint ? type_constraint : scope->schema->inttype; - - if (type == scope->schema->inttype) - expr = to_string(d100()); - else if (type == scope->schema->booltype) - expr += (d6() > 3) ? scope->schema->true_literal : scope->schema->false_literal; - else if (dynamic_cast(p) && (d6() > 3)) - expr += "default"; - else - expr += "cast(null as " + type->name + ")"; -} - -funcall::funcall(prod *p, sqltype *type_constraint, bool agg) : value_expr(p), is_aggregate(agg) { - if (type_constraint == scope->schema->internaltype) - fail("cannot call functions involving internal type"); - - auto &idx = agg ? p->scope->schema->aggregates_returning_type - : (4 < d6()) ? p->scope->schema->routines_returning_type - : p->scope->schema->parameterless_routines_returning_type; - -retry: - - if (!type_constraint) { - proc = random_pick(idx.begin(), idx.end())->second; - } else { - auto iters = idx.equal_range(type_constraint); - proc = random_pick<>(iters)->second; - if (proc && !type_constraint->consistent(proc->restype)) { - retry(); - goto retry; - } - } - - if (!proc) { - retry(); - goto retry; - } - - if (type_constraint) - type = type_constraint; - else - type = proc->restype; - - if (type == scope->schema->internaltype) { - retry(); - goto retry; - } - - for (auto type : proc->argtypes) - if (type == scope->schema->internaltype || type == scope->schema->arraytype) { - retry(); - goto retry; - } - - for (auto argtype : proc->argtypes) { - assert(argtype); - auto expr = value_expr::factory(this, argtype); - parms.push_back(expr); - } -} - -void funcall::out(std::ostream &out) { - out << proc->ident() << "("; - for (auto expr = parms.begin(); expr != parms.end(); expr++) { - indent(out); - out << "cast(" << **expr << " as " << (*expr)->type->name << ")"; - if (expr + 1 != parms.end()) - out << ","; - } - - if (is_aggregate && (parms.begin() == parms.end())) - out << "*"; - out << ")"; -} - -atomic_subselect::atomic_subselect(prod *p, sqltype *type_constraint) - : value_expr(p), offset((d6() == 6) ? d100() : d6()) { - match(); - if (d6() < 3) { - if (type_constraint) { - auto idx = scope->schema->aggregates_returning_type; - auto iters = idx.equal_range(type_constraint); - agg = random_pick<>(iters)->second; - } else { - agg = &random_pick<>(scope->schema->aggregates); - } - if (agg->argtypes.size() != 1) - agg = 0; - else - type_constraint = agg->argtypes[0]; - } else { - agg = 0; - } - - if (type_constraint) { - auto idx = scope->schema->tables_with_columns_of_type; - col = 0; - auto iters = idx.equal_range(type_constraint); - tab = random_pick<>(iters)->second; - - for (auto &cand : tab->columns()) { - if (type_constraint->consistent(cand.type)) { - col = &cand; - break; - } - } - assert(col); - } else { - tab = &random_pick<>(scope->schema->tables); - col = &random_pick<>(tab->columns()); - } - - type = agg ? agg->restype : col->type; -} - -void atomic_subselect::out(std::ostream &out) { - out << "(select "; - - if (agg) - out << agg->ident() << "(" << col->name << ")"; - else - out << col->name; - - out << " from " << tab->ident(); - - if (!agg) - out << " limit 1 offset " << offset; - - out << ")"; - indent(out); -} - -void window_function::out(std::ostream &out) { - indent(out); - out << *aggregate << " over (partition by "; - - for (auto ref = partition_by.begin(); ref != partition_by.end(); ref++) { - out << **ref; - if (ref + 1 != partition_by.end()) - out << ","; - } - - out << " order by "; - - for (auto ref = order_by.begin(); ref != order_by.end(); ref++) { - out << **ref; - if (ref + 1 != order_by.end()) - out << ","; - } - - out << ")"; -} - -window_function::window_function(prod *p, sqltype *type_constraint) : value_expr(p) { - match(); - aggregate = std::make_shared(this, type_constraint, true); - type = aggregate->type; - partition_by.push_back(std::make_shared(this)); - while (d6() > 4) - partition_by.push_back(std::make_shared(this)); - - order_by.push_back(std::make_shared(this)); - while (d6() > 4) - order_by.push_back(std::make_shared(this)); -} - -bool window_function::allowed(prod *p) { - if (dynamic_cast(p)) - return dynamic_cast(p->pprod) ? true : false; - if (dynamic_cast(p)) - return false; - if (dynamic_cast(p)) - return allowed(p->pprod); - return false; -} diff --git a/extension/sqlsmith/third_party/sqlsmith/grammar.cc b/extension/sqlsmith/third_party/sqlsmith/grammar.cc deleted file mode 100644 index 61f0ade6e21..00000000000 --- a/extension/sqlsmith/third_party/sqlsmith/grammar.cc +++ /dev/null @@ -1,618 +0,0 @@ -#include -#include -#include -#include -#include - -#include "random.hh" -#include "relmodel.hh" -#include "grammar.hh" -#include "schema.hh" -#include "impedance.hh" - -using namespace std; - -shared_ptr table_ref::factory(prod *p) { - try { - if (p->level < 3 + d6()) { - if (d6() > 3 && p->level < d6()) - return std::make_shared(p); - if (d6() > 3) - return std::make_shared(p); - } - if (d6() > 3) - return std::make_shared(p); - else - return std::make_shared(p); - } catch (runtime_error &e) { - p->retry(); - } - return factory(p); -} - -table_or_query_name::table_or_query_name(prod *p) : table_ref(p) { - t = random_pick(scope->tables); - refs.push_back(std::make_shared(scope->stmt_uid("ref"), t)); -} - -void table_or_query_name::out(std::ostream &out) { - out << t->ident() << " as " << refs[0]->ident(); -} - -target_table::target_table(prod *p, table *victim) : table_ref(p) { - while (!victim || victim->schema == "pg_catalog" || !victim->is_base_table || !victim->columns().size()) { - struct named_relation *pick = random_pick(scope->tables); - victim = dynamic_cast(pick); - retry(); - } - victim_ = victim; - refs.push_back(std::make_shared(scope->stmt_uid("target"), victim)); -} - -void target_table::out(std::ostream &out) { - out << victim_->ident() << " as " << refs[0]->ident(); -} - -table_sample::table_sample(prod *p) : table_ref(p) { - match(); - retry_limit = 1000; /* retries are cheap here */ - do { - auto pick = random_pick(scope->schema->base_tables); - t = dynamic_cast(pick); - retry(); - } while (!t || !t->is_base_table); - - refs.push_back(std::make_shared(scope->stmt_uid("sample"), t)); - percent = 0.1 * d100(); - method = (d6() > 2) ? "system" : "bernoulli"; -} - -void table_sample::out(std::ostream &out) { - out << t->ident() << " as " << refs[0]->ident() << " tablesample " << method << " (" << percent << ") "; -} - -table_subquery::table_subquery(prod *p, bool lateral) : table_ref(p), is_lateral(lateral) { - query = std::make_shared(this, scope, lateral); - string alias = scope->stmt_uid("subq"); - relation *aliased_rel = &query->select_list->derived_table; - refs.push_back(std::make_shared(alias, aliased_rel)); -} - -table_subquery::~table_subquery() { -} - -void table_subquery::accept(prod_visitor *v) { - query->accept(v); - v->visit(this); -} - -shared_ptr join_cond::factory(prod *p, table_ref &lhs, table_ref &rhs) { - try { - if (d6() < 6) - return std::make_shared(p, lhs, rhs); - else - return std::make_shared(p, lhs, rhs); - } catch (runtime_error &e) { - p->retry(); - } - return factory(p, lhs, rhs); -} - -simple_join_cond::simple_join_cond(prod *p, table_ref &lhs, table_ref &rhs) : join_cond(p, lhs, rhs) { -retry: - named_relation *left_rel = &*random_pick(lhs.refs); - - if (!left_rel->columns().size()) { - retry(); - goto retry; - } - - named_relation *right_rel = &*random_pick(rhs.refs); - - column &c1 = random_pick(left_rel->columns()); - - for (auto c2 : right_rel->columns()) { - if (c1.type == c2.type) { - condition += left_rel->ident() + "." + c1.name + " = " + right_rel->ident() + "." + c2.name + " "; - break; - } - } - if (condition == "") { - retry(); - goto retry; - } -} - -void simple_join_cond::out(std::ostream &out) { - out << condition; -} - -expr_join_cond::expr_join_cond(prod *p, table_ref &lhs, table_ref &rhs) : join_cond(p, lhs, rhs), joinscope(p->scope) { - scope = &joinscope; - for (auto ref : lhs.refs) - joinscope.refs.push_back(&*ref); - for (auto ref : rhs.refs) - joinscope.refs.push_back(&*ref); - search = bool_expr::factory(this); -} - -void expr_join_cond::out(std::ostream &out) { - out << *search; -} - -joined_table::joined_table(prod *p) : table_ref(p) { - lhs = table_ref::factory(this); - rhs = table_ref::factory(this); - - condition = join_cond::factory(this, *lhs, *rhs); - - if (d6() < 4) { - type = "inner"; - } else if (d6() < 4) { - type = "left"; - } else { - type = "right"; - } - - for (auto ref : lhs->refs) - refs.push_back(ref); - for (auto ref : rhs->refs) - refs.push_back(ref); -} - -void joined_table::out(std::ostream &out) { - out << *lhs; - indent(out); - out << type << " join " << *rhs; - indent(out); - out << "on (" << *condition << ")"; -} - -void table_subquery::out(std::ostream &out) { - if (is_lateral) - out << "lateral "; - out << "(" << *query << ") as " << refs[0]->ident(); -} - -void from_clause::out(std::ostream &out) { - if (!reflist.size()) - return; - out << "from "; - - for (auto r = reflist.begin(); r < reflist.end(); r++) { - indent(out); - out << **r; - if (r + 1 != reflist.end()) - out << ","; - } -} - -from_clause::from_clause(prod *p) : prod(p) { - reflist.push_back(table_ref::factory(this)); - for (auto r : reflist.back()->refs) - scope->refs.push_back(&*r); - - while (d6() > 5) { - // add a lateral subquery - if (!impedance::matched(typeid(lateral_subquery))) - break; - reflist.push_back(std::make_shared(this)); - for (auto r : reflist.back()->refs) - scope->refs.push_back(&*r); - } -} - -select_list::select_list(prod *p) : prod(p) { - do { - shared_ptr e = value_expr::factory(this); - value_exprs.push_back(e); - ostringstream name; - name << "c" << columns++; - sqltype *t = e->type; - assert(t); - derived_table.columns().push_back(column(name.str(), t)); - } while (d6() > 1); -} - -void select_list::out(std::ostream &out) { - int i = 0; - for (auto expr = value_exprs.begin(); expr != value_exprs.end(); expr++) { - indent(out); - out << **expr << " as " << derived_table.columns()[i].name; - i++; - if (expr + 1 != value_exprs.end()) - out << ", "; - } -} - -void query_spec::out(std::ostream &out) { - out << "select " << set_quantifier << " " << *select_list; - indent(out); - out << *from_clause; - indent(out); - out << "where "; - out << *search; - if (limit_clause.length()) { - indent(out); - out << limit_clause; - } -} - -struct for_update_verify : prod_visitor { - virtual void visit(prod *p) { - if (dynamic_cast(p)) - throw("window function"); - joined_table *join = dynamic_cast(p); - if (join && join->type != "inner") - throw("outer join"); - query_spec *subquery = dynamic_cast(p); - if (subquery) - subquery->set_quantifier = ""; - table_or_query_name *tab = dynamic_cast(p); - if (tab) { - table *actual_table = dynamic_cast
(tab->t); - if (actual_table && !actual_table->is_insertable) - throw("read only"); - if (actual_table->name.find("pg_")) - throw("catalog"); - } - table_sample *sample = dynamic_cast(p); - if (sample) { - table *actual_table = dynamic_cast
(sample->t); - if (actual_table && !actual_table->is_insertable) - throw("read only"); - if (actual_table->name.find("pg_")) - throw("catalog"); - } - }; -}; - -select_for_update::select_for_update(prod *p, struct scope *s, bool lateral) : query_spec(p, s, lateral) { - static const char *modes[] = { - "update", - "share", - "no key update", - "key share", - }; - - try { - for_update_verify v1; - this->accept(&v1); - - } catch (const char *reason) { - lockmode = 0; - return; - } - lockmode = modes[d6() % (sizeof(modes) / sizeof(*modes))]; - set_quantifier = ""; // disallow distinct -} - -void select_for_update::out(std::ostream &out) { - query_spec::out(out); - if (lockmode) { - indent(out); - out << " for " << lockmode; - } -} - -query_spec::query_spec(prod *p, struct scope *s, bool lateral) : prod(p), myscope(s) { - scope = &myscope; - scope->tables = s->tables; - - if (lateral) - scope->refs = s->refs; - - from_clause = std::make_shared(this); - select_list = std::make_shared(this); - - set_quantifier = (d100() == 1) ? "distinct" : ""; - - search = bool_expr::factory(this); - - if (d6() > 2) { - ostringstream cons; - cons << "limit " << d100() + d100(); - limit_clause = cons.str(); - } -} - -long prepare_stmt::seq; - -void modifying_stmt::pick_victim() { - do { - struct named_relation *pick = random_pick(scope->tables); - victim = dynamic_cast(pick); - retry(); - } while (!victim || victim->schema == "pg_catalog" || !victim->is_base_table || !victim->columns().size()); -} - -modifying_stmt::modifying_stmt(prod *p, struct scope *s, table *victim) : prod(p), myscope(s) { - scope = &myscope; - scope->tables = s->tables; - - if (!victim) - pick_victim(); -} - -delete_stmt::delete_stmt(prod *p, struct scope *s, table *v) : modifying_stmt(p, s, v) { - scope->refs.push_back(victim); - search = bool_expr::factory(this); -} - -delete_returning::delete_returning(prod *p, struct scope *s, table *victim) : delete_stmt(p, s, victim) { - match(); - select_list = std::make_shared(this); -} - -insert_stmt::insert_stmt(prod *p, struct scope *s, table *v) : modifying_stmt(p, s, v) { - match(); - - for (auto col : victim->columns()) { - auto expr = value_expr::factory(this, col.type); - assert(expr->type == col.type); - value_exprs.push_back(expr); - } -} - -void insert_stmt::out(std::ostream &out) { - out << "insert into " << victim->ident() << " "; - - if (!value_exprs.size()) { - out << "default values"; - return; - } - - out << "values ("; - - for (auto expr = value_exprs.begin(); expr != value_exprs.end(); expr++) { - indent(out); - out << **expr; - if (expr + 1 != value_exprs.end()) - out << ", "; - } - out << ")"; -} - -set_list::set_list(prod *p, table *target) : prod(p) { - do { - for (auto col : target->columns()) { - if (d6() < 4) - continue; - auto expr = value_expr::factory(this, col.type); - value_exprs.push_back(expr); - names.push_back(col.name); - } - } while (!names.size()); -} - -void set_list::out(std::ostream &out) { - assert(names.size()); - out << " set "; - for (size_t i = 0; i < names.size(); i++) { - indent(out); - out << names[i] << " = " << *value_exprs[i]; - if (i + 1 != names.size()) - out << ", "; - } -} - -update_stmt::update_stmt(prod *p, struct scope *s, table *v) : modifying_stmt(p, s, v) { - scope->refs.push_back(victim); - search = bool_expr::factory(this); - set_list = std::make_shared(this, victim); -} - -void update_stmt::out(std::ostream &out) { - out << "update " << victim->ident() << *set_list; -} - -update_returning::update_returning(prod *p, struct scope *s, table *v) : update_stmt(p, s, v) { - match(); - - select_list = std::make_shared(this); -} - -upsert_stmt::upsert_stmt(prod *p, struct scope *s, table *v) : insert_stmt(p, s, v) { - match(); - - if (!victim->constraints.size()) - fail("need table w/ constraint for upsert"); - - set_list = std::make_shared(this, victim); - search = bool_expr::factory(this); - constraint = random_pick(victim->constraints); -} - -shared_ptr statement_factory(struct scope *s) { - try { - s->new_stmt(); - if (d42() == 1) - return std::make_shared((struct prod *)0, s); - if (d42() == 1) - return std::make_shared((struct prod *)0, s); - else if (d42() == 1) - return std::make_shared((struct prod *)0, s); - else if (d42() == 1) { - return std::make_shared((struct prod *)0, s); - } else if (d42() == 1) - return std::make_shared((struct prod *)0, s); - else if (d6() > 4) - return std::make_shared((struct prod *)0, s); - else if (d6() > 5) - return std::make_shared((struct prod *)0, s); - return std::make_shared((struct prod *)0, s); - } catch (runtime_error &e) { - return statement_factory(s); - } -} - -void common_table_expression::accept(prod_visitor *v) { - v->visit(this); - for (auto q : with_queries) - q->accept(v); - query->accept(v); -} - -common_table_expression::common_table_expression(prod *parent, struct scope *s) : prod(parent), myscope(s) { - scope = &myscope; - do { - shared_ptr query = std::make_shared(this, s); - with_queries.push_back(query); - string alias = scope->stmt_uid("jennifer"); - relation *relation = &query->select_list->derived_table; - auto aliased_rel = std::make_shared(alias, relation); - refs.push_back(aliased_rel); - scope->tables.push_back(&*aliased_rel); - - } while (d6() > 2); - -retry: - do { - auto pick = random_pick(s->tables); - scope->tables.push_back(pick); - } while (d6() > 3); - try { - query = std::make_shared(this, scope); - } catch (runtime_error &e) { - retry(); - goto retry; - } -} - -void common_table_expression::out(std::ostream &out) { - out << "WITH "; - for (size_t i = 0; i < with_queries.size(); i++) { - indent(out); - out << refs[i]->ident() << " AS " - << "(" << *with_queries[i] << ")"; - if (i + 1 != with_queries.size()) - out << ", "; - indent(out); - } - out << *query; - indent(out); -} - -merge_stmt::merge_stmt(prod *p, struct scope *s, table *v) : modifying_stmt(p, s, v) { - match(); - target_table_ = std::make_shared(this, victim); - data_source = table_ref::factory(this); - // join_condition = join_cond::factory(this, *target_table_, - // *data_source); - join_condition = std::make_shared(this, *target_table_, *data_source); - - /* Put data_source into scope but not target_table. Visibility of - the latter varies depending on kind of when clause. */ - // for (auto r : data_source->refs) - // scope->refs.push_back(&*r); - - clauselist.push_back(when_clause::factory(this)); - while (d6() > 4) - clauselist.push_back(when_clause::factory(this)); -} - -void merge_stmt::out(std::ostream &out) { - out << "MERGE INTO " << *target_table_; - indent(out); - out << "USING " << *data_source; - indent(out); - out << "ON " << *join_condition; - indent(out); - for (auto p : clauselist) { - out << *p; - indent(out); - } -} - -void merge_stmt::accept(prod_visitor *v) { - v->visit(this); - target_table_->accept(v); - data_source->accept(v); - join_condition->accept(v); - for (auto p : clauselist) - p->accept(v); -} - -when_clause::when_clause(merge_stmt *p) : prod(p) { - condition = bool_expr::factory(this); - matched = d6() > 3; -} - -void when_clause::out(std::ostream &out) { - out << (matched ? "WHEN MATCHED " : "WHEN NOT MATCHED"); - indent(out); - out << "AND " << *condition; - indent(out); - out << " THEN "; - out << (matched ? "DELETE" : "DO NOTHING"); -} - -void when_clause::accept(prod_visitor *v) { - v->visit(this); - condition->accept(v); -} - -when_clause_update::when_clause_update(merge_stmt *p) : when_clause(p), myscope(p->scope) { - myscope.tables = scope->tables; - myscope.refs = scope->refs; - scope = &myscope; - scope->refs.push_back(&*(p->target_table_->refs[0])); - - set_list = std::make_shared(this, p->victim); -} - -void when_clause_update::out(std::ostream &out) { - out << "WHEN MATCHED AND " << *condition; - indent(out); - out << " THEN UPDATE " << *set_list; -} - -void when_clause_update::accept(prod_visitor *v) { - v->visit(this); - set_list->accept(v); -} - -when_clause_insert::when_clause_insert(struct merge_stmt *p) : when_clause(p) { - for (auto col : p->victim->columns()) { - auto expr = value_expr::factory(this, col.type); - assert(expr->type == col.type); - exprs.push_back(expr); - } -} - -void when_clause_insert::out(std::ostream &out) { - out << "WHEN NOT MATCHED AND " << *condition; - indent(out); - out << " THEN INSERT VALUES ( "; - - for (auto expr = exprs.begin(); expr != exprs.end(); expr++) { - out << **expr; - if (expr + 1 != exprs.end()) - out << ", "; - } - out << ")"; -} - -void when_clause_insert::accept(prod_visitor *v) { - v->visit(this); - for (auto p : exprs) - p->accept(v); -} - -shared_ptr when_clause::factory(struct merge_stmt *p) { - try { - switch (d6()) { - case 1: - case 2: - return std::make_shared(p); - case 3: - case 4: - return std::make_shared(p); - default: - return std::make_shared(p); - } - } catch (runtime_error &e) { - p->retry(); - } - return factory(p); -} diff --git a/extension/sqlsmith/third_party/sqlsmith/impedance.cc b/extension/sqlsmith/third_party/sqlsmith/impedance.cc deleted file mode 100644 index d8f121a729c..00000000000 --- a/extension/sqlsmith/third_party/sqlsmith/impedance.cc +++ /dev/null @@ -1,88 +0,0 @@ -#include "impedance.hh" -#include "log.hh" -#include - -using namespace std; - -static map occurances_in_failed_query; -static map occurances_in_ok_query; -static map retries; -static map limited; -static map failed; - -impedance_visitor::impedance_visitor(map &occured) : _occured(occured) { -} - -void impedance_visitor::visit(struct prod *p) { - found[typeid(*p).name()] = true; -} - -impedance_visitor::~impedance_visitor() { - for (auto pair : found) - _occured[pair.first]++; -} - -void impedance_feedback::executed(prod &query) { - impedance_visitor v(occurances_in_ok_query); - query.accept(&v); -} - -void impedance_feedback::error(prod &query, const dut::failure &e) { - (void)e; - impedance_visitor v(occurances_in_failed_query); - query.accept(&v); -} - -namespace impedance { - -bool matched(const char *name) { - if (100 > occurances_in_failed_query[name]) - return true; - double error_rate = - (double)occurances_in_failed_query[name] / (occurances_in_failed_query[name] + occurances_in_ok_query[name]); - if (error_rate > 0.99) - return false; - return true; -} - -void report() { - cerr << "impedance report: " << endl; - for (auto pair : occurances_in_failed_query) { - cerr << " " << pretty_type(pair.first) << ": " << pair.second << "/" << occurances_in_ok_query[pair.first] - << " (bad/ok)"; - if (!matched(pair.first)) - cerr << " -> BLACKLISTED"; - cerr << endl; - } -} - -void report(std::ostream &out) { - out << "{\"impedance\": [ " << endl; - - for (auto pair = occurances_in_failed_query.begin(); pair != occurances_in_failed_query.end(); ++pair) { - out << "{\"prod\": \"" << pretty_type(pair->first) << "\"," - << "\"bad\": " << pair->second << ", " - << "\"ok\": " << occurances_in_ok_query[pair->first] << ", " - << "\"limited\": " << limited[pair->first] << ", " - << "\"failed\": " << failed[pair->first] << ", " - << "\"retries\": " << retries[pair->first] << "} "; - - if (next(pair) != occurances_in_failed_query.end()) - out << "," << endl; - } - out << "]}" << endl; -} - -void retry(const char *p) { - retries[p]++; -} - -void limit(const char *p) { - limited[p]++; -} - -void fail(const char *p) { - failed[p]++; -} - -} // namespace impedance diff --git a/extension/sqlsmith/third_party/sqlsmith/include/duckdb.hh b/extension/sqlsmith/third_party/sqlsmith/include/duckdb.hh deleted file mode 100644 index b61b4e14f83..00000000000 --- a/extension/sqlsmith/third_party/sqlsmith/include/duckdb.hh +++ /dev/null @@ -1,33 +0,0 @@ -/// @file -/// @brief schema and dut classes for DuckDB - -#ifndef DUCKDB_HH -#define DUCKDB_HH - -#include "duckdb.hpp" - -#include "dut.hh" -#include "relmodel.hh" -#include "schema.hh" - -struct sqlsmith_duckdb_connection { - duckdb::unique_ptr database; - duckdb::unique_ptr connection; - char *zErrMsg = 0; - int rc; - void q(const char *query); - sqlsmith_duckdb_connection(duckdb::DatabaseInstance &database); -}; - -struct schema_duckdb : schema, sqlsmith_duckdb_connection { - schema_duckdb(duckdb::DatabaseInstance &database, bool no_catalog, bool verbose_output); - virtual std::string quote_name(const std::string &id) { - return id; - } -}; - -struct dut_duckdb : dut_base, sqlsmith_duckdb_connection { - virtual void test(const std::string &stmt); - dut_duckdb(duckdb::DatabaseInstance &database); -}; -#endif diff --git a/extension/sqlsmith/third_party/sqlsmith/include/dump.hh b/extension/sqlsmith/third_party/sqlsmith/include/dump.hh deleted file mode 100644 index c3d296ca3c1..00000000000 --- a/extension/sqlsmith/third_party/sqlsmith/include/dump.hh +++ /dev/null @@ -1,27 +0,0 @@ -/// @file -/// @brief Dump syntax trees as GraphML -#ifndef DUMP_HH -#define DUMP_HH - -#include -#include -#include - -#include "log.hh" -#include "prod.hh" - -struct graphml_dumper : prod_visitor { - std::ostream &o; - virtual void visit(struct prod *p); - graphml_dumper(std::ostream &out); - std::string id(prod *p); - std::string type(struct prod *p); - virtual ~graphml_dumper(); -}; - -struct ast_logger : logger { - int queries = 0; - virtual void generated(prod &query); -}; - -#endif diff --git a/extension/sqlsmith/third_party/sqlsmith/include/dut.hh b/extension/sqlsmith/third_party/sqlsmith/include/dut.hh deleted file mode 100644 index fb49fb4e3bc..00000000000 --- a/extension/sqlsmith/third_party/sqlsmith/include/dut.hh +++ /dev/null @@ -1,47 +0,0 @@ -/// @file -/// @brief Base class for device under test - -#ifndef DUT_HH -#define DUT_HH -#include -#include - -#include "prod.hh" - -namespace dut { - -struct failure : public std::exception { - std::string errstr; - std::string sqlstate; - const char *what() const throw() { - return errstr.c_str(); - } - failure(const char *s, const char *sqlstate_ = "") throw() : errstr(), sqlstate() { - errstr = s; - sqlstate = sqlstate_; - }; -}; - -struct broken : failure { - broken(const char *s, const char *sqlstate_ = "") throw() : failure(s, sqlstate_) { - } -}; - -struct timeout : failure { - timeout(const char *s, const char *sqlstate_ = "") throw() : failure(s, sqlstate_) { - } -}; - -struct syntax : failure { - syntax(const char *s, const char *sqlstate_ = "") throw() : failure(s, sqlstate_) { - } -}; - -} // namespace dut - -struct dut_base { - std::string version; - virtual void test(const std::string &stmt) = 0; -}; - -#endif diff --git a/extension/sqlsmith/third_party/sqlsmith/include/expr.hh b/extension/sqlsmith/third_party/sqlsmith/include/expr.hh deleted file mode 100644 index 5b72669231f..00000000000 --- a/extension/sqlsmith/third_party/sqlsmith/include/expr.hh +++ /dev/null @@ -1,208 +0,0 @@ -/// @file -/// @brief grammar: Value expression productions - -#ifndef EXPR_HH -#define EXPR_HH - -#include "prod.hh" -#include -#include "duckdb/common/vector.hpp" - -using duckdb::vector; -using std::shared_ptr; -using std::string; - -struct value_expr : prod { - sqltype *type; - virtual void out(std::ostream &out) = 0; - virtual ~value_expr() { - } - value_expr(prod *p) : prod(p) { - } - static shared_ptr factory(prod *p, sqltype *type_constraint = 0); -}; - -struct case_expr : value_expr { - shared_ptr condition; - shared_ptr true_expr; - shared_ptr false_expr; - case_expr(prod *p, sqltype *type_constraint = 0); - virtual void out(std::ostream &out); - virtual void accept(prod_visitor *v); -}; - -struct funcall : value_expr { - routine *proc; - bool is_aggregate; - vector> parms; - virtual void out(std::ostream &out); - virtual ~funcall() { - } - funcall(prod *p, sqltype *type_constraint = 0, bool agg = 0); - virtual void accept(prod_visitor *v) { - v->visit(this); - for (auto p : parms) - p->accept(v); - } -}; - -struct atomic_subselect : value_expr { - table *tab; - column *col; - int offset; - routine *agg; - atomic_subselect(prod *p, sqltype *type_constraint = 0); - virtual void out(std::ostream &out); -}; - -struct const_expr : value_expr { - std::string expr; - const_expr(prod *p, sqltype *type_constraint = 0); - virtual void out(std::ostream &out) { - out << expr; - } - virtual ~const_expr() { - } -}; - -struct column_reference : value_expr { - column_reference(prod *p, sqltype *type_constraint = 0); - virtual void out(std::ostream &out) { - out << reference; - } - std::string reference; - virtual ~column_reference() { - } -}; - -struct coalesce : value_expr { - const char *abbrev_; - vector> value_exprs; - virtual ~coalesce() {}; - coalesce(prod *p, sqltype *type_constraint = 0, const char *abbrev = "coalesce"); - virtual void out(std::ostream &out); - virtual void accept(prod_visitor *v) { - v->visit(this); - for (auto p : value_exprs) - p->accept(v); - } -}; - -struct nullif : coalesce { - virtual ~nullif() {}; - nullif(prod *p, sqltype *type_constraint = 0) : coalesce(p, type_constraint, "nullif") {}; -}; - -struct bool_expr : value_expr { - virtual ~bool_expr() { - } - bool_expr(prod *p) : value_expr(p) { - type = scope->schema->booltype; - } - static shared_ptr factory(prod *p); -}; - -struct truth_value : bool_expr { - virtual ~truth_value() { - } - const char *op; - virtual void out(std::ostream &out) { - out << op; - } - truth_value(prod *p) : bool_expr(p) { - op = ((d6() < 4) ? scope->schema->true_literal : scope->schema->false_literal); - } -}; - -struct null_predicate : bool_expr { - virtual ~null_predicate() { - } - const char *negate; - shared_ptr expr; - null_predicate(prod *p) : bool_expr(p) { - negate = ((d6() < 4) ? "not " : ""); - expr = value_expr::factory(this); - } - virtual void out(std::ostream &out) { - out << *expr << " is " << negate << "NULL"; - } - virtual void accept(prod_visitor *v) { - v->visit(this); - expr->accept(v); - } -}; - -struct exists_predicate : bool_expr { - shared_ptr subquery; - virtual ~exists_predicate() { - } - exists_predicate(prod *p); - virtual void out(std::ostream &out); - virtual void accept(prod_visitor *v); -}; - -struct bool_binop : bool_expr { - shared_ptr lhs, rhs; - bool_binop(prod *p) : bool_expr(p) { - } - virtual void out(std::ostream &out) = 0; - virtual void accept(prod_visitor *v) { - v->visit(this); - lhs->accept(v); - rhs->accept(v); - } -}; - -struct bool_term : bool_binop { - virtual ~bool_term() { - } - const char *op; - virtual void out(std::ostream &out) { - out << "(" << *lhs << ") "; - indent(out); - out << op << " (" << *rhs << ")"; - } - bool_term(prod *p) : bool_binop(p) { - op = ((d6() < 4) ? "or" : "and"); - lhs = bool_expr::factory(this); - rhs = bool_expr::factory(this); - } -}; - -struct distinct_pred : bool_binop { - distinct_pred(prod *p); - virtual ~distinct_pred() {}; - virtual void out(std::ostream &o) { - o << *lhs << " is distinct from " << *rhs; - } -}; - -struct comparison_op : bool_binop { - op *oper; - comparison_op(prod *p); - virtual ~comparison_op() {}; - virtual void out(std::ostream &o) { - o << *lhs << " " << oper->name << " " << *rhs; - } -}; - -struct window_function : value_expr { - virtual void out(std::ostream &out); - virtual ~window_function() { - } - window_function(prod *p, sqltype *type_constraint); - vector> partition_by; - vector> order_by; - shared_ptr aggregate; - static bool allowed(prod *pprod); - virtual void accept(prod_visitor *v) { - v->visit(this); - aggregate->accept(v); - for (auto p : partition_by) - p->accept(v); - for (auto p : order_by) - p->accept(v); - } -}; - -#endif diff --git a/extension/sqlsmith/third_party/sqlsmith/include/grammar.hh b/extension/sqlsmith/third_party/sqlsmith/include/grammar.hh deleted file mode 100644 index 1eba224e149..00000000000 --- a/extension/sqlsmith/third_party/sqlsmith/include/grammar.hh +++ /dev/null @@ -1,367 +0,0 @@ -/// @file -/// @brief grammar: Top-level and unsorted grammar productions - -#ifndef GRAMMAR_HH -#define GRAMMAR_HH - -#include "relmodel.hh" -#include "schema.hh" -#include -#include - -#include "expr.hh" -#include "prod.hh" - -using std::shared_ptr; - -struct table_ref : prod { - vector> refs; - static shared_ptr factory(prod *p); - table_ref(prod *p) : prod(p) { - } - virtual ~table_ref() { - } -}; - -struct table_or_query_name : table_ref { - virtual void out(std::ostream &out); - table_or_query_name(prod *p); - virtual ~table_or_query_name() { - } - named_relation *t; -}; - -struct target_table : table_ref { - virtual void out(std::ostream &out); - target_table(prod *p, table *victim = 0); - virtual ~target_table() { - } - table *victim_; -}; - -struct table_sample : table_ref { - virtual void out(std::ostream &out); - table_sample(prod *p); - virtual ~table_sample() { - } - struct table *t; - -private: - string method; - double percent; -}; - -struct table_subquery : table_ref { - bool is_lateral; - virtual void out(std::ostream &out); - shared_ptr query; - table_subquery(prod *p, bool lateral = false); - virtual ~table_subquery(); - virtual void accept(prod_visitor *v); -}; - -struct lateral_subquery : table_subquery { - lateral_subquery(prod *p) : table_subquery(p, true) { - } -}; - -struct join_cond : prod { - static shared_ptr factory(prod *p, table_ref &lhs, table_ref &rhs); - join_cond(prod *p, table_ref &lhs, table_ref &rhs) : prod(p) { - (void)lhs; - (void)rhs; - } - virtual ~join_cond() { - } -}; - -struct simple_join_cond : join_cond { - std::string condition; - simple_join_cond(prod *p, table_ref &lhs, table_ref &rhs); - virtual ~simple_join_cond() { - } - virtual void out(std::ostream &out); -}; - -struct expr_join_cond : join_cond { - struct scope joinscope; - shared_ptr search; - expr_join_cond(prod *p, table_ref &lhs, table_ref &rhs); - virtual ~expr_join_cond() { - } - virtual void out(std::ostream &out); - virtual void accept(prod_visitor *v) { - search->accept(v); - v->visit(this); - } -}; - -struct joined_table : table_ref { - virtual void out(std::ostream &out); - joined_table(prod *p); - std::string type; - std::string alias; - virtual std::string ident() { - return alias; - } - shared_ptr lhs; - shared_ptr rhs; - shared_ptr condition; - virtual ~joined_table() { - } - virtual void accept(prod_visitor *v) { - lhs->accept(v); - rhs->accept(v); - condition->accept(v); - v->visit(this); - } -}; - -struct from_clause : prod { - vector> reflist; - virtual void out(std::ostream &out); - from_clause(prod *p); - virtual ~from_clause() { - } - virtual void accept(prod_visitor *v) { - v->visit(this); - for (auto p : reflist) - p->accept(v); - } -}; - -struct select_list : prod { - vector> value_exprs; - relation derived_table; - int columns = 0; - select_list(prod *p); - virtual void out(std::ostream &out); - virtual ~select_list() { - } - virtual void accept(prod_visitor *v) { - v->visit(this); - for (auto p : value_exprs) - p->accept(v); - } -}; - -struct query_spec : prod { - std::string set_quantifier; - shared_ptr from_clause; - shared_ptr select_list; - shared_ptr search; - std::string limit_clause; - struct scope myscope; - virtual void out(std::ostream &out); - query_spec(prod *p, struct scope *s, bool lateral = 0); - virtual ~query_spec() { - } - virtual void accept(prod_visitor *v) { - v->visit(this); - select_list->accept(v); - from_clause->accept(v); - search->accept(v); - } -}; - -struct select_for_update : query_spec { - const char *lockmode; - virtual void out(std::ostream &out); - select_for_update(prod *p, struct scope *s, bool lateral = 0); - virtual ~select_for_update() { - } -}; - -struct prepare_stmt : prod { - query_spec q; - static long seq; - long id; - virtual void out(std::ostream &out) { - out << "prepare prep" << id << " as " << q; - } - prepare_stmt(prod *p) : prod(p), q(p, scope) { - id = seq++; - } - virtual ~prepare_stmt() { - } - virtual void accept(prod_visitor *v) { - v->visit(this); - q.accept(v); - } -}; - -struct modifying_stmt : prod { - table *victim; - struct scope myscope; - modifying_stmt(prod *p, struct scope *s, struct table *victim = 0); - virtual ~modifying_stmt() { - } - // shared_ptr modifying_stmt::factory(prod *p, struct - // scope *s); - virtual void pick_victim(); -}; - -struct delete_stmt : modifying_stmt { - shared_ptr search; - delete_stmt(prod *p, struct scope *s, table *v); - virtual ~delete_stmt() { - } - virtual void out(std::ostream &out) { - out << "delete from " << victim->ident(); - indent(out); - out << "where " << std::endl << *search; - } - virtual void accept(prod_visitor *v) { - v->visit(this); - search->accept(v); - } -}; - -struct delete_returning : delete_stmt { - shared_ptr select_list; - delete_returning(prod *p, struct scope *s, table *victim = 0); - virtual void out(std::ostream &out) { - delete_stmt::out(out); - out << std::endl << "returning " << *select_list; - } - virtual void accept(prod_visitor *v) { - v->visit(this); - search->accept(v); - select_list->accept(v); - } -}; - -struct insert_stmt : modifying_stmt { - vector> value_exprs; - insert_stmt(prod *p, struct scope *s, table *victim = 0); - virtual ~insert_stmt() { - } - virtual void out(std::ostream &out); - virtual void accept(prod_visitor *v) { - v->visit(this); - for (auto p : value_exprs) - p->accept(v); - } -}; - -struct set_list : prod { - vector> value_exprs; - vector names; - set_list(prod *p, table *target); - virtual ~set_list() { - } - virtual void out(std::ostream &out); - virtual void accept(prod_visitor *v) { - v->visit(this); - for (auto p : value_exprs) - p->accept(v); - } -}; - -struct upsert_stmt : insert_stmt { - shared_ptr set_list; - string constraint; - shared_ptr search; - upsert_stmt(prod *p, struct scope *s, table *v = 0); - virtual void out(std::ostream &out) { - insert_stmt::out(out); - out << " on conflict on constraint " << constraint << " do update "; - out << *set_list << " where " << *search; - } - virtual void accept(prod_visitor *v) { - insert_stmt::accept(v); - set_list->accept(v); - search->accept(v); - } - virtual ~upsert_stmt() { - } -}; - -struct update_stmt : modifying_stmt { - shared_ptr search; - shared_ptr set_list; - update_stmt(prod *p, struct scope *s, table *victim = 0); - virtual ~update_stmt() { - } - virtual void out(std::ostream &out); - virtual void accept(prod_visitor *v) { - v->visit(this); - search->accept(v); - } -}; - -struct when_clause : prod { - bool matched; - shared_ptr condition; - // shared_ptr merge_action; - when_clause(struct merge_stmt *p); - virtual ~when_clause() { - } - static shared_ptr factory(struct merge_stmt *p); - virtual void out(std::ostream &out); - virtual void accept(prod_visitor *v); -}; - -struct when_clause_update : when_clause { - shared_ptr set_list; - struct scope myscope; - when_clause_update(struct merge_stmt *p); - virtual ~when_clause_update() { - } - virtual void out(std::ostream &out); - virtual void accept(prod_visitor *v); -}; - -struct when_clause_insert : when_clause { - vector> exprs; - when_clause_insert(struct merge_stmt *p); - virtual ~when_clause_insert() { - } - virtual void out(std::ostream &out); - virtual void accept(prod_visitor *v); -}; - -struct merge_stmt : modifying_stmt { - merge_stmt(prod *p, struct scope *s, table *victim = 0); - shared_ptr target_table_; - shared_ptr data_source; - shared_ptr join_condition; - vector> clauselist; - virtual ~merge_stmt() { - } - virtual void out(std::ostream &out); - virtual void accept(prod_visitor *v); -}; - -struct update_returning : update_stmt { - shared_ptr select_list; - update_returning(prod *p, struct scope *s, table *victim = 0); - virtual ~update_returning() { - } - virtual void out(std::ostream &out) { - update_stmt::out(out); - out << std::endl << "returning " << *select_list; - } - virtual void accept(prod_visitor *v) { - v->visit(this); - search->accept(v); - set_list->accept(v); - select_list->accept(v); - } -}; - -shared_ptr statement_factory(struct scope *s); - -struct common_table_expression : prod { - vector> with_queries; - shared_ptr query; - vector> refs; - struct scope myscope; - virtual void out(std::ostream &out); - virtual void accept(prod_visitor *v); - common_table_expression(prod *parent, struct scope *s); - virtual ~common_table_expression() { - } -}; - -#endif diff --git a/extension/sqlsmith/third_party/sqlsmith/include/impedance.hh b/extension/sqlsmith/third_party/sqlsmith/include/impedance.hh deleted file mode 100644 index 8fc73b52b60..00000000000 --- a/extension/sqlsmith/third_party/sqlsmith/include/impedance.hh +++ /dev/null @@ -1,62 +0,0 @@ -/// @file -/// @brief feedback to the grammar about failed productions - -#ifndef IMPEDANCE_HH -#define IMPEDANCE_HH - -#include "dut.hh" -#include "log.hh" -#include "prod.hh" -#include "util.hh" -#include -#include - -struct impedance_visitor : prod_visitor { - std::map &_occured; - std::map found; - virtual void visit(struct prod *p); - impedance_visitor(std::map &occured); - virtual ~impedance_visitor(); -}; - -struct impedance_feedback : logger { - virtual void executed(prod &query); - virtual void error(prod &query, const dut::failure &e); - impedance_feedback() { - } -}; - -namespace impedance { -bool matched(const char *p); -inline bool matched(const std::type_info &id) { - return matched(id.name()); -} -inline bool matched(prod *p) { - return matched(typeid(*p)); -} -void retry(const char *p); -inline void retry(const std::type_info &id) { - return retry(id.name()); -} -inline void retry(prod *p) { - return retry(typeid(*p)); -} -void limit(const char *p); -inline void limit(const std::type_info &id) { - return limit(id.name()); -} -inline void limit(prod *p) { - return limit(typeid(*p)); -} -void fail(const char *p); -inline void fail(const std::type_info &id) { - return fail(id.name()); -} -inline void fail(prod *p) { - return fail(typeid(*p)); -} -void report(); -void report(std::ostream &out); -} // namespace impedance - -#endif diff --git a/extension/sqlsmith/third_party/sqlsmith/include/log.hh b/extension/sqlsmith/third_party/sqlsmith/include/log.hh deleted file mode 100644 index 5412b690cab..00000000000 --- a/extension/sqlsmith/third_party/sqlsmith/include/log.hh +++ /dev/null @@ -1,55 +0,0 @@ -/// @file -/// @brief logging - -#ifndef LOG_HH -#define LOG_HH - -#include -#include -#include - -#include "dut.hh" -#include "prod.hh" - -/// logger base class -struct logger { - virtual void generated(prod &query) { - (void)query; - } - virtual void executed(prod &query) { - (void)query; - } - virtual void error(prod &query, const dut::failure &e) { - (void)query, (void)e; - } -}; - -/// logger to dump all generated queries -struct query_dumper : logger { - virtual void generated(prod &query) { - query.out(std::cout); - std::cout << ";" << std::endl; - } -}; - -/// logger for statistics collection -struct stats_collecting_logger : logger { - long queries = 0; - float sum_nodes = 0; - float sum_height = 0; - float sum_retries = 0; - virtual void generated(prod &query); -}; - -/// stderr logger -struct cerr_logger : stats_collecting_logger { - const int columns = 80; - std::map errors; - virtual void report(); - virtual void generated(prod &query); - virtual void executed(prod &query); - virtual void error(prod &query, const dut::failure &e); - void report(prod &p); -}; - -#endif diff --git a/extension/sqlsmith/third_party/sqlsmith/include/prod.hh b/extension/sqlsmith/third_party/sqlsmith/include/prod.hh deleted file mode 100644 index 409d836d235..00000000000 --- a/extension/sqlsmith/third_party/sqlsmith/include/prod.hh +++ /dev/null @@ -1,59 +0,0 @@ -/// @file -/// @brief Base class for grammar productions - -#include -#include - -#ifndef PROD_HH -#define PROD_HH - -/// Base class for walking the AST -struct prod_visitor { - virtual void visit(struct prod *p) = 0; - virtual ~prod_visitor() { - } -}; - -/// Base class for AST nodes -struct prod { - /// Parent production that instanciated this one. May be NULL for - /// top-level productions. - struct prod *pprod; - /// Scope object to model column/table reference visibility. - struct scope *scope; - /// Level of this production in the AST. 0 for root node. - int level; - /// Number of retries in this production. Child productions are - /// generated speculatively and may fail. - long retries = 0; - /// Maximum number of retries allowed before reporting a failure to - /// the Parent prod. - long retry_limit = 100; - prod(prod *parent); - virtual ~prod() { - } - /// Newline and indent according to tree level. - virtual void indent(std::ostream &out); - /// Emit SQL for this production. - virtual void out(std::ostream &out) = 0; - /// Check with the impedance matching code whether this production - /// has been blacklisted and throw an exception. - virtual void match(); - /// Visitor pattern for walking the AST. Make sure you visit all - /// child production when deriving classes. - virtual void accept(prod_visitor *v) { - v->visit(this); - } - /// Report a "failed to generate" error. - virtual void fail(const char *reason); - /// Increase the retry count and throw an exception when retry_limit - /// is exceeded. - void retry(); -}; - -inline std::ostream &operator<<(std::ostream &s, prod &p) { - p.out(s); - return s; -} - -#endif diff --git a/extension/sqlsmith/third_party/sqlsmith/include/random.hh b/extension/sqlsmith/third_party/sqlsmith/include/random.hh deleted file mode 100644 index e38a3543a91..00000000000 --- a/extension/sqlsmith/third_party/sqlsmith/include/random.hh +++ /dev/null @@ -1,45 +0,0 @@ -/// @file -/// @brief randomness - -#ifndef RANDOM_HH -#define RANDOM_HH - -#include -#include -#include -#include -#include "duckdb/common/vector.hpp" - -namespace smith { -extern std::mt19937_64 rng; -} - -using duckdb::vector; - -template -T &random_pick(vector &container) { - if (!container.size()) - throw std::runtime_error("No candidates available"); - - std::uniform_int_distribution pick(0, container.size() - 1); - return container[pick(smith::rng)]; -} - -template -I random_pick(I beg, I end) { - if (beg == end) - throw std::runtime_error("No candidates available"); - - std::uniform_int_distribution<> pick(0, std::distance(beg, end) - 1); - std::advance(beg, pick(smith::rng)); - return beg; -} - -template -I random_pick(std::pair iters) { - return random_pick(iters.first, iters.second); -} - -int d6(), d9(), d12(), d20(), d42(), d100(); - -#endif diff --git a/extension/sqlsmith/third_party/sqlsmith/include/relmodel.hh b/extension/sqlsmith/third_party/sqlsmith/include/relmodel.hh deleted file mode 100644 index 5019ee881fa..00000000000 --- a/extension/sqlsmith/third_party/sqlsmith/include/relmodel.hh +++ /dev/null @@ -1,163 +0,0 @@ -/// @file -/// @brief supporting classes for the grammar - -#ifndef RELMODEL_HH -#define RELMODEL_HH -#include -#include -#include -#include -#include -#include "duckdb/common/vector.hpp" - -using duckdb::vector; -using std::make_pair; -using std::map; -using std::pair; -using std::shared_ptr; -using std::string; - -struct sqltype { - string name; - static map typemap; - static struct sqltype *get(string s); - static const map &get_types(); - sqltype(string n) : name(n) { - } - - /** This function is used to model postgres-style pseudotypes. - A generic type is consistent with a more concrete type. - E.G., anyarray->consistent(intarray) is true - while int4array->consistent(anyarray) is false - - There must not be cycles in the consistency graph, since the - grammar will use fixpoint iteration to resolve type conformance - situations in the direction of more concrete types */ - virtual bool consistent(struct sqltype *rvalue); -}; - -struct column { - string name; - sqltype *type; - column(string name) : name(name) { - } - column(string name, sqltype *t) : name(name), type(t) { - assert(t); - } -}; - -struct relation { - vector cols; - virtual ~relation() { - } - virtual vector &columns() { - return cols; - } -}; - -struct named_relation : relation { - string name; - virtual string ident() { - return name; - } - virtual ~named_relation() { - } - named_relation(string n) : name(n) { - } -}; - -struct aliased_relation : named_relation { - relation *rel; - virtual ~aliased_relation() { - } - aliased_relation(string n, relation *r) : named_relation(n), rel(r) { - } - virtual vector &columns() { - return rel->columns(); - } -}; - -struct table : named_relation { - string schema; - bool is_insertable; - bool is_base_table; - vector constraints; - table(string name, string schema, bool insertable, bool base_table) - : named_relation(name), schema(schema), is_insertable(insertable), is_base_table(base_table) { - } - virtual string ident() { - return schema + "." + name; - } - virtual ~table() {}; -}; - -struct scope { - struct scope *parent; - /// available to table_ref productions - vector tables; - /// available to column_ref productions - vector refs; - struct schema *schema; - /// Counters for prefixed stmt-unique identifiers - shared_ptr> stmt_seq; - scope(struct scope *parent = 0) : parent(parent) { - if (parent) { - schema = parent->schema; - tables = parent->tables; - refs = parent->refs; - stmt_seq = parent->stmt_seq; - } - } - vector> refs_of_type(sqltype *t) { - vector> result; - for (auto r : refs) - for (auto c : r->columns()) - if (t->consistent(c.type)) - result.push_back(make_pair(r, c)); - return result; - } - /** Generate unique identifier with prefix. */ - string stmt_uid(const char *prefix) { - string result(prefix); - result += "_"; - result += std::to_string((*stmt_seq)[result]++); - return result; - } - /** Reset unique identifier counters. */ - void new_stmt() { - stmt_seq = std::make_shared>(); - } -}; - -struct op { - string name; - sqltype *left; - sqltype *right; - sqltype *result; - op(string n, sqltype *l, sqltype *r, sqltype *res) : name(n), left(l), right(r), result(res) { - } - op() { - } -}; - -struct routine { - string specific_name; - string schema; - vector argtypes; - sqltype *restype; - string name; - routine(string schema, string specific_name, sqltype *data_type, string name) - : specific_name(specific_name), schema(schema), restype(data_type), name(name) { - assert(data_type); - } - virtual ~routine() { - } - virtual string ident() { - if (schema.size()) - return schema + "." + name; - else - return name; - } -}; - -#endif diff --git a/extension/sqlsmith/third_party/sqlsmith/include/schema.hh b/extension/sqlsmith/third_party/sqlsmith/include/schema.hh deleted file mode 100644 index 3363d863e11..00000000000 --- a/extension/sqlsmith/third_party/sqlsmith/include/schema.hh +++ /dev/null @@ -1,84 +0,0 @@ -/// @file -/// @brief Base class providing schema information to grammar - -#ifndef SCHEMA_HH -#define SCHEMA_HH - -#include -#include -#include -#include - -#include "random.hh" -#include "relmodel.hh" - -using duckdb::vector; - -struct schema { - sqltype *booltype; - sqltype *inttype; - sqltype *internaltype; - sqltype *arraytype; - - vector types; - - vector
tables; - vector operators; - vector routines; - vector aggregates; - - typedef std::tuple typekey; - std::multimap index; - typedef std::multimap::iterator op_iterator; - - std::multimap routines_returning_type; - std::multimap aggregates_returning_type; - std::multimap parameterless_routines_returning_type; - std::multimap tables_with_columns_of_type; - std::multimap operators_returning_type; - std::multimap concrete_type; - vector
base_tables; - - string version; - int version_num; // comparable version number - - const char *true_literal = "true"; - const char *false_literal = "false"; - - virtual std::string quote_name(const std::string &id) = 0; - - void summary() { - std::cout << "Found " << tables.size() << " user table(s) in information schema." << std::endl; - } - void fill_scope(struct scope &s) { - for (auto &t : tables) - s.tables.push_back(&t); - s.schema = this; - } - virtual void register_operator(op &o) { - operators.push_back(o); - typekey t(o.left, o.right, o.result); - index.insert(std::pair(t, o)); - } - virtual void register_routine(routine &r) { - routines.push_back(r); - } - virtual void register_aggregate(routine &r) { - aggregates.push_back(r); - } - virtual op_iterator find_operator(sqltype *left, sqltype *right, sqltype *res) { - typekey t(left, right, res); - auto cons = index.equal_range(t); - if (cons.first == cons.second) - return index.end(); - else - return random_pick<>(cons.first, cons.second); - } - schema() { - } - virtual ~schema() { - } - void generate_indexes(bool verbose_output); -}; - -#endif diff --git a/extension/sqlsmith/third_party/sqlsmith/include/sqlsmith.hh b/extension/sqlsmith/third_party/sqlsmith/include/sqlsmith.hh deleted file mode 100644 index 4bcf23bc16e..00000000000 --- a/extension/sqlsmith/third_party/sqlsmith/include/sqlsmith.hh +++ /dev/null @@ -1,27 +0,0 @@ -/// @file -/// @brief Base class providing schema information to grammar - -#ifndef SQLSMITH_HH -#define SQLSMITH_HH - -#include -#include "duckdb.hh" - -namespace duckdb_sqlsmith { - -struct SQLSmithOptions { - int32_t seed = -1; - uint64_t max_queries = 0; - bool exclude_catalog = false; - bool dump_all_queries = false; - bool dump_all_graphs = false; - bool verbose_output = false; - std::string complete_log; - std::string log; -}; - -int32_t run_sqlsmith(duckdb::DatabaseInstance &database, SQLSmithOptions options); - -} // namespace duckdb_sqlsmith - -#endif diff --git a/extension/sqlsmith/third_party/sqlsmith/include/util.hh b/extension/sqlsmith/third_party/sqlsmith/include/util.hh deleted file mode 100644 index c237e9d4ce0..00000000000 --- a/extension/sqlsmith/third_party/sqlsmith/include/util.hh +++ /dev/null @@ -1,25 +0,0 @@ -#ifndef UTIL_HH -#define UTIL_HH -#include -#include -#include - -using namespace std; - -/* TODO: The strings are implementation-defined. How do they look in - clang? */ - -inline std::string pretty_type(const char *raw) { - ostringstream os; - os << raw; - string s = os.str(); - while (s[0] <= '9') - s.erase(s.begin()); - return s; -} - -inline std::string pretty_type(struct prod *p) { - return pretty_type(typeid(*p).name()); -} - -#endif diff --git a/extension/sqlsmith/third_party/sqlsmith/log.cc b/extension/sqlsmith/third_party/sqlsmith/log.cc deleted file mode 100644 index 287e9d381fe..00000000000 --- a/extension/sqlsmith/third_party/sqlsmith/log.cc +++ /dev/null @@ -1,107 +0,0 @@ -#include -#include - -#include - -#include - -#include "log.hh" -#include "schema.hh" -#include "impedance.hh" -#include "random.hh" - -#include "duckdb/common/vector.hpp" - -using namespace std; - -struct stats_visitor : prod_visitor { - int nodes = 0; - int maxlevel = 0; - long retries = 0; - map production_stats; - virtual void visit(struct prod *p) { - nodes++; - if (p->level > maxlevel) - maxlevel = p->level; - production_stats[typeid(*p).name()]++; - retries += p->retries; - } - void report() { - cerr << "production statistics" << endl; - duckdb::vector> report; - for (auto p : production_stats) - report.push_back(p); - stable_sort( - report.begin(), report.end(), - [](const pair &a, const pair &b) { return a.second > b.second; }); - for (auto p : report) { - cerr << p.second << "\t" << p.first << endl; - } - } -}; - -void stats_collecting_logger::generated(prod &query) { - queries++; - - stats_visitor v; - query.accept(&v); - - sum_nodes += v.nodes; - sum_height += v.maxlevel; - sum_retries += v.retries; -} - -void cerr_logger::report() { - cerr << endl << "queries: " << queries << endl; - // << " (" << 1000.0*query_count/gen_time.count() << " gen/s, " - // << 1000.0*query_count/query_time.count() << " exec/s)" << endl; - cerr << "AST stats (avg): height = " << sum_height / queries << " nodes = " << sum_nodes / queries << endl; - - duckdb::vector> report; - for (auto e : errors) { - report.push_back(e); - } - stable_sort(report.begin(), report.end(), - [](const pair &a, const pair &b) { return a.second > b.second; }); - long err_count = 0; - for (auto e : report) { - err_count += e.second; - cerr << e.second << "\t" << e.first.substr(0, 80) << endl; - } - cerr << "error rate: " << (float)err_count / (queries) << endl; - impedance::report(); -} - -void cerr_logger::generated(prod &p) { - stats_collecting_logger::generated(p); - if ((10 * columns - 1) == queries % (10 * columns)) - report(); -} - -void cerr_logger::executed(prod &query) { - (void)query; - if (columns - 1 == (queries % columns)) { - cerr << endl; - } - cerr << "."; -} - -void cerr_logger::error(prod &query, const dut::failure &e) { - (void)query; - istringstream err(e.what()); - string line; - - if (columns - 1 == (queries % columns)) { - cerr << endl; - } - getline(err, line); - errors[line]++; - if (dynamic_cast(&e)) - cerr << "t"; - else if (dynamic_cast(&e)) - cerr << "S"; - else if (dynamic_cast(&e)) - cerr << "C"; - else - cerr << "e"; -} diff --git a/extension/sqlsmith/third_party/sqlsmith/prod.cc b/extension/sqlsmith/third_party/sqlsmith/prod.cc deleted file mode 100644 index bd90c3af4aa..00000000000 --- a/extension/sqlsmith/third_party/sqlsmith/prod.cc +++ /dev/null @@ -1,41 +0,0 @@ -/// @file -/// @brief Base class for grammar productions -#include -#include -#include "prod.hh" -#include "impedance.hh" - -prod::prod(struct prod *parent) : pprod(parent) { - if (parent) { - level = parent->level + 1; - scope = parent->scope; - } else { - scope = 0; - level = 0; - } -} - -void prod::indent(std::ostream &out) { - out << std::endl; - for (int i = 0; i < level; i++) - out << " "; -} - -void prod::retry() { - impedance::retry(this); - if (retries++ <= retry_limit) - return; - - impedance::limit(this); - throw std::runtime_error(std::string("excessive retries in ") + typeid(*this).name()); -} - -void prod::match() { - if (!impedance::matched(this)) - throw std::runtime_error("impedance mismatch"); -} - -void prod::fail(const char *reason) { - impedance::fail(this); - throw std::runtime_error(reason); -} diff --git a/extension/sqlsmith/third_party/sqlsmith/random.cc b/extension/sqlsmith/third_party/sqlsmith/random.cc deleted file mode 100644 index 8952e36e1ab..00000000000 --- a/extension/sqlsmith/third_party/sqlsmith/random.cc +++ /dev/null @@ -1,35 +0,0 @@ -#include "random.hh" - -namespace smith { -std::mt19937_64 rng; -} - -int d6() { - static std::uniform_int_distribution<> pick(1, 6); - return pick(smith::rng); -} - -int d9() { - static std::uniform_int_distribution<> pick(1, 9); - return pick(smith::rng); -} - -int d12() { - static std::uniform_int_distribution<> pick(1, 12); - return pick(smith::rng); -} - -int d20() { - static std::uniform_int_distribution<> pick(1, 20); - return pick(smith::rng); -} - -int d42() { - static std::uniform_int_distribution<> pick(1, 42); - return pick(smith::rng); -} - -int d100() { - static std::uniform_int_distribution<> pick(1, 100); - return pick(smith::rng); -} diff --git a/extension/sqlsmith/third_party/sqlsmith/relmodel.cc b/extension/sqlsmith/third_party/sqlsmith/relmodel.cc deleted file mode 100644 index 3bb313f298e..00000000000 --- a/extension/sqlsmith/third_party/sqlsmith/relmodel.cc +++ /dev/null @@ -1,23 +0,0 @@ -#include "relmodel.hh" -#include -#include -#include - -map sqltype::typemap; - -sqltype *sqltype::get(string n) { - std::transform(n.begin(), n.end(), n.begin(), [](unsigned char c) { return std::tolower(c); }); - - if (typemap.count(n)) - return typemap[n]; - else - return typemap[n] = new sqltype(n); -} - -const map &sqltype::get_types() { - return typemap; -} - -bool sqltype::consistent(struct sqltype *rvalue) { - return this == rvalue; -} diff --git a/extension/sqlsmith/third_party/sqlsmith/schema.cc b/extension/sqlsmith/third_party/sqlsmith/schema.cc deleted file mode 100644 index 3164bb2ca64..00000000000 --- a/extension/sqlsmith/third_party/sqlsmith/schema.cc +++ /dev/null @@ -1,59 +0,0 @@ -#include "schema.hh" -#include "relmodel.hh" -#include - -using namespace std; - -void schema::generate_indexes(bool verbose_output) { - - if (verbose_output) - cerr << "Generating indexes..."; - - for (auto &type : types) { - assert(type); - for (auto &r : aggregates) { - if (type->consistent(r.restype)) - aggregates_returning_type.insert(pair(type, &r)); - } - - for (auto &r : routines) { - if (!type->consistent(r.restype)) - continue; - routines_returning_type.insert(pair(type, &r)); - if (!r.argtypes.size()) - parameterless_routines_returning_type.insert(pair(type, &r)); - } - - for (auto &t : tables) { - for (auto &c : t.columns()) { - if (type->consistent(c.type)) { - tables_with_columns_of_type.insert(pair(type, &t)); - break; - } - } - } - - for (auto &concrete : types) { - if (type->consistent(concrete)) - concrete_type.insert(pair(type, concrete)); - } - - for (auto &o : operators) { - if (type->consistent(o.result)) - operators_returning_type.insert(pair(type, &o)); - } - } - - for (auto &t : tables) { - if (t.is_base_table) - base_tables.push_back(&t); - } - - if (verbose_output) - cerr << "done." << endl; - - assert(booltype); - assert(inttype); - assert(internaltype); - assert(arraytype); -} diff --git a/extension/sqlsmith/third_party/sqlsmith/sqlsmith.cc b/extension/sqlsmith/third_party/sqlsmith/sqlsmith.cc deleted file mode 100644 index 90483ae0d5c..00000000000 --- a/extension/sqlsmith/third_party/sqlsmith/sqlsmith.cc +++ /dev/null @@ -1,202 +0,0 @@ -#include -#include - -#include - -#include -#include - -#include -#include - -#include "grammar.hh" -#include "random.hh" -#include "relmodel.hh" -#include "schema.hh" - -#include "dump.hh" -#include "dut.hh" -#include "impedance.hh" -#include "log.hh" - -#include "duckdb.hh" -#include "sqlsmith.hh" - -#include "duckdb/common/vector.hpp" - -using namespace std; - -using namespace std::chrono; - -extern "C" { -#include -#include -#if (!defined(_WIN32) && !defined(WIN32)) || defined(__MINGW32__) -#include -#define GETPID ::getpid -#else -#include -#define GETPID (int)GetCurrentProcessId -#endif -} - -/* make the cerr logger globally accessible so we can emit one last - report on SIGINT */ -cerr_logger *global_cerr_logger; - -extern "C" void cerr_log_handler(int) { - if (global_cerr_logger) - global_cerr_logger->report(); - exit(1); -} - -namespace duckdb_sqlsmith { - -int32_t run_sqlsmith(duckdb::DatabaseInstance &database, SQLSmithOptions opt) { - // - // if (options.count("help")) { - // cerr << " --duckdb=URI SQLite database to send queries to" << endl - // << " --seed=int seed RNG with specified int instead " - // "of PID" - // << endl - // << " --dump-all-queries print queries as they are generated" << endl - // << " --dump-all-graphs dump generated ASTs" << endl - // << " --dry-run print queries instead of executing " - // "them" - // << endl - // << " --exclude-catalog don't generate queries using catalog " - // "relations" - // << endl - // << " --max-queries=long terminate after generating this many " - // "queries" - // << endl - // << " --rng-state=string deserialize dumped rng state" << endl - // << " --verbose emit progress output" << endl - // << " --version print version information and exit" << endl - // << " --help print available command line options " - // "and exit" - // << endl; - // return 0; - // } else if (options.count("version")) { - // return 0; - // } - - try { - shared_ptr schema; - schema = std::make_shared(database, opt.exclude_catalog, opt.verbose_output); - - scope scope; - long queries_generated = 0; - schema->fill_scope(scope); - - // if (options.count("rng-state")) { - // istringstream(options["rng-state"]) >> smith::rng; - // } else { - smith::rng.seed(opt.seed >= 0 ? opt.seed : GETPID()); - // } - - duckdb::vector> loggers; - - loggers.push_back(std::make_shared()); - - if (opt.verbose_output) { - auto l = std::make_shared(); - global_cerr_logger = &*l; - loggers.push_back(l); - signal(SIGINT, cerr_log_handler); - } - - if (opt.dump_all_graphs) - loggers.push_back(std::make_shared()); - - if (opt.dump_all_queries) - loggers.push_back(std::make_shared()); - - // if (options.count("dry-run")) { - // while (1) { - // shared_ptr gen = statement_factory(&scope); - // gen->out(cout); - // for (auto l : loggers) - // l->generated(*gen); - // cout << ";" << endl; - // queries_generated++; - // - // if (opt.max_queries >= 0 && (queries_generated >= opt.max_queries)) - // return 0; - // } - // } - - shared_ptr dut; - - dut = std::make_shared(database); - - if (opt.verbose_output) - cerr << "Running queries..." << endl; - - bool has_complete_log = !opt.complete_log.empty(); - bool has_log = !opt.log.empty(); - ofstream complete_log; - if (has_complete_log) { - complete_log.open(opt.complete_log); - } - while (1) /* Loop to recover connection loss */ - { - while (1) { /* Main loop */ - - if (opt.max_queries >= 0 && (++queries_generated > opt.max_queries)) { - if (global_cerr_logger) - global_cerr_logger->report(); - return 0; - } - - /* Invoke top-level production to generate AST */ - shared_ptr gen = statement_factory(&scope); - - for (auto l : loggers) - l->generated(*gen); - - /* Generate SQL from AST */ - ostringstream s; - gen->out(s); - - // write the query to the complete log that has all the - // queries - if (has_complete_log) { - complete_log << s.str() << ";" << endl; - complete_log.flush(); - } - - // write the last-executed query to a separate log file - if (has_log) { - ofstream out_file; - out_file.open(opt.log); - out_file << s.str() << ";" << endl; - out_file.close(); - } - - /* Try to execute it */ - try { - dut->test(s.str()); - for (auto l : loggers) - l->executed(*gen); - } catch (const dut::failure &e) { - for (auto l : loggers) - try { - l->error(*gen, e); - } catch (runtime_error &e) { - cerr << endl << "log failed: " << typeid(*l).name() << ": " << e.what() << endl; - } - if ((dynamic_cast(&e))) { - /* re-throw to outer loop */ - throw; - } - } - } - } - } catch (const exception &e) { - cerr << e.what() << endl; - exit(1); - } -} - -} // namespace duckdb_sqlsmith diff --git a/extension/tpch/dbgen/bm_utils.cpp b/extension/tpch/dbgen/bm_utils.cpp index 80c1575a3df..b6fbf205cef 100644 --- a/extension/tpch/dbgen/bm_utils.cpp +++ b/extension/tpch/dbgen/bm_utils.cpp @@ -89,7 +89,7 @@ static char alpha_num[65] = "0123456789abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMN char *getenv PROTO((const char *name)); #endif void usage(); -void permute_dist(distribution *d, seed_t *seed); +void permute_dist(distribution *d, seed_t *seed, DBGenContext *ctx); /* * tpch_env_config: look for a environmental variable setting and return its @@ -302,7 +302,6 @@ void read_dist(const char *path, const char *name, distribution *target) { fprintf(stderr, "Read error on dist '%s'\n", name); exit(1); } - target->permute = (long *)NULL; return; } @@ -310,16 +309,16 @@ void read_dist(const char *path, const char *name, distribution *target) { * agg_str(set, count) build an aggregated string from count unique * selections taken from set */ -void agg_str(distribution *set, long count, seed_t *seed, char *dest) { +void agg_str(distribution *set, long count, seed_t *seed, char *dest, DBGenContext *ctx) { distribution *d; int i; d = set; *dest = '\0'; - permute_dist(d, seed); + permute_dist(d, seed, ctx); for (i = 0; i < count; i++) { - strcat(dest, DIST_MEMBER(set, DIST_PERMUTE(d, i))); + strcat(dest, DIST_MEMBER(set, ctx->permute[i])); strcat(dest, " "); } *(dest + (int)strlen(dest) - 1) = '\0'; diff --git a/extension/tpch/dbgen/build.cpp b/extension/tpch/dbgen/build.cpp index 8d03b0f362a..808f6c8e3d1 100644 --- a/extension/tpch/dbgen/build.cpp +++ b/extension/tpch/dbgen/build.cpp @@ -10,6 +10,7 @@ */ #include #include +#include #ifndef VMS #include #endif @@ -20,6 +21,7 @@ #include "dbgen/dsstypes.h" #include + #include "dbgen/rng64.h" #define LEAP_ADJ(yr, mnth) ((LEAP(yr) && (mnth) >= 2) ? 1 : 0) @@ -64,13 +66,12 @@ static void gen_phone(DSS_HUGE ind, char *target, seed_t *seed) { long mk_cust(DSS_HUGE n_cust, customer_t *c, DBGenContext *ctx) { DSS_HUGE i; - static int bInit = 0; + static std::once_flag bInit; static char szFormat[100]; - if (!bInit) { + std::call_once (bInit, [&](){ snprintf(szFormat, sizeof(szFormat), C_NAME_FMT, 9, &HUGE_FORMAT[1]); - bInit = 1; - } + }); c->custkey = n_cust; snprintf(c->name, sizeof(c->name), szFormat, C_NAME_TAG, n_cust); V_STR(C_ADDR_LEN, &ctx->Seed[C_ADDR_SD], c->address); @@ -117,15 +118,13 @@ long mk_order(DSS_HUGE index, order_t *o, DBGenContext *ctx, long upd_num) { char tmp_str[2]; char **mk_ascdate PROTO((void)); int delta = 1; - static int bInit = 0; + static std::once_flag bInit; static char szFormat[100]; - if (!bInit) { + std::call_once (bInit, [&](){ snprintf(szFormat, sizeof(szFormat), O_CLRK_FMT, 9, &HUGE_FORMAT[1]); - bInit = 1; - } - if (asc_date == NULL) asc_date = mk_ascdate(); + }); mk_sparse(index, &o->okey, (upd_num == 0) ? 0 : 1 + upd_num / (10000 / UPD_PCT)); if (ctx->scale_factor >= 30000) RANDOM64(o->custkey, O_CKEY_MIN, O_CKEY_MAX, &ctx->Seed[O_CKEY_SD]); @@ -216,17 +215,17 @@ long mk_part(DSS_HUGE index, part_t *p, DBGenContext *ctx) { DSS_HUGE temp; long snum; DSS_HUGE brnd; - static int bInit = 0; + static std::once_flag bInit; static char szFormat[100]; static char szBrandFormat[100]; - if (!bInit) { + + std::call_once (bInit, [&](){ snprintf(szFormat, sizeof(szFormat), P_MFG_FMT, 1, &HUGE_FORMAT[1]); snprintf(szBrandFormat, sizeof(szBrandFormat), P_BRND_FMT, 2, &HUGE_FORMAT[1]); - bInit = 1; - } + }); p->partkey = index; - agg_str(&colors, (long)P_NAME_SCL, &ctx->Seed[P_NAME_SD], p->name); + agg_str(&colors, (long)P_NAME_SCL, &ctx->Seed[P_NAME_SD], p->name, ctx); RANDOM(temp, P_MFG_MIN, P_MFG_MAX, &ctx->Seed[P_MFG_SD]); snprintf(p->mfgr, sizeof(p->mfgr), szFormat, P_MFG_TAG, temp); RANDOM(brnd, P_BRND_MIN, P_BRND_MAX, &ctx->Seed[P_BRND_SD]); @@ -252,13 +251,12 @@ long mk_part(DSS_HUGE index, part_t *p, DBGenContext *ctx) { long mk_supp(DSS_HUGE index, supplier_t *s, DBGenContext *ctx) { DSS_HUGE i, bad_press, noise, offset, type; - static int bInit = 0; + static std::once_flag bInit; static char szFormat[100]; - if (!bInit) { + std::call_once (bInit, [&](){ snprintf(szFormat, sizeof(szFormat), S_NAME_FMT, 9, &HUGE_FORMAT[1]); - bInit = 1; - } + }); s->suppkey = index; snprintf(s->name, sizeof(s->name), szFormat, S_NAME_TAG, index); V_STR(S_ADDR_LEN, &ctx->Seed[S_ADDR_SD], s->address); diff --git a/extension/tpch/dbgen/dbgen.cpp b/extension/tpch/dbgen/dbgen.cpp index c6e938068db..09a1aaac71e 100644 --- a/extension/tpch/dbgen/dbgen.cpp +++ b/extension/tpch/dbgen/dbgen.cpp @@ -11,6 +11,9 @@ #include "duckdb/catalog/catalog.hpp" #include "duckdb/main/appender.hpp" #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp" +#ifndef DUCKDB_NO_THREADS +#include "duckdb/common/thread.hpp" +#endif #endif #define DECLARER /* EXTERN references get defined here */ @@ -473,16 +476,97 @@ void skip(int table, int children, DSS_HUGE step, DBGenContext &dbgen_ctx) { } } +struct TPCHDBgenParameters { + TPCHDBgenParameters(ClientContext &context, Catalog &catalog, const string &schema, const string &suffix) { + tables.resize(REGION + 1); + for (size_t i = PART; i <= REGION; i++) { + auto tname = get_table_name(i); + if (!tname.empty()) { + string full_tname = string(tname) + string(suffix); + auto &tbl_catalog = catalog.GetEntry(context, schema, full_tname); + tables[i] = &tbl_catalog; + } + } + + } + + vector> tables; +}; + +class TPCHDataAppender { +public: + TPCHDataAppender(ClientContext &context, TPCHDBgenParameters ¶meters, DBGenContext base_context, idx_t flush_count) : + context(context), parameters(parameters) { + dbgen_ctx = base_context; + append_info = duckdb::unique_ptr(new tpch_append_information[REGION + 1]); + memset(append_info.get(), 0, sizeof(tpch_append_information) * REGION + 1); + for (size_t i = PART; i <= REGION; i++) { + if (parameters.tables[i]) { + auto &tbl_catalog = *parameters.tables[i]; + append_info[i].appender = make_uniq(context, tbl_catalog, flush_count); + } + } + } + + void GenerateTableData(int table_index, idx_t row_count, idx_t offset) { + gen_tbl(context, table_index, static_cast(row_count), append_info.get(), &dbgen_ctx, offset); + } + + void AppendData(int children, int current_step) { + DSS_HUGE i; + DSS_HUGE rowcnt = 0; + for (i = PART; i <= REGION; i++) { + if (table & (1 << i)) { + if (i < NATION) { + rowcnt = dbgen_ctx.tdefs[i].base * dbgen_ctx.scale_factor; + } else { + rowcnt = dbgen_ctx.tdefs[i].base; + } + if (children > 1 && current_step != -1) { + size_t part_size = std::ceil((double)rowcnt / (double)children); + auto part_offset = part_size * current_step; + auto part_end = part_offset + part_size; + rowcnt = part_end > rowcnt ? rowcnt - part_offset : part_size; + skip(i, children, part_offset, dbgen_ctx); + if (rowcnt > 0) { + // generate part of the table + GenerateTableData((int) i, rowcnt, part_offset); + } + } else { + // generate full table + GenerateTableData((int) i, rowcnt, 0); + } + } + } + } + + void Flush() { + // flush any incomplete chunks + for (idx_t i = PART; i <= REGION; i++) { + if (append_info[i].appender) { + append_info[i].appender->Flush(); + append_info[i].appender.reset(); + } + } + } + +private: + ClientContext &context; + TPCHDBgenParameters ¶meters; + unique_ptr append_info; + DBGenContext dbgen_ctx; +}; + +static void ParallelTPCHAppend(TPCHDataAppender *appender, int children, int current_step) { + appender->AppendData(children, current_step); +} + void DBGenWrapper::LoadTPCHData(ClientContext &context, double flt_scale, string catalog_name, string schema, - string suffix, int children_p, int current_step) { + string suffix, int children, int current_step) { if (flt_scale == 0) { return; } - // generate the actual data - DSS_HUGE rowcnt = 0; - DSS_HUGE extra; - DSS_HUGE i; // all tables table = (1 << CUST) | (1 << SUPP) | (1 << NATION) | (1 << REGION) | (1 << PART_PSUPP) | (1 << ORDER_LINE); force = 0; @@ -495,9 +579,10 @@ void DBGenWrapper::LoadTPCHData(ClientContext &context, double flt_scale, string set_seeds = 0; updates = 0; - DBGenContext dbgen_ctx; + d_path = NULL; - tdef *tdefs = dbgen_ctx.tdefs; + DBGenContext base_context; + tdef *tdefs = base_context.tdefs; tdefs[PART].base = 200000; tdefs[PSUPP].base = 200000; tdefs[SUPP].base = 10000; @@ -509,18 +594,11 @@ void DBGenWrapper::LoadTPCHData(ClientContext &context, double flt_scale, string tdefs[NATION].base = NATIONS_MAX; tdefs[REGION].base = NATIONS_MAX; - children = children_p; - d_path = NULL; - - if (current_step >= children) { - return; - } - if (flt_scale < MIN_SCALE) { int i; int int_scale; - dbgen_ctx.scale_factor = 1; + base_context.scale_factor = 1; int_scale = (int)(1000 * flt_scale); for (i = PART; i < REGION; i++) { tdefs[i].base = (DSS_HUGE)(int_scale * tdefs[i].base) / 1000; @@ -529,58 +607,76 @@ void DBGenWrapper::LoadTPCHData(ClientContext &context, double flt_scale, string } } } else { - dbgen_ctx.scale_factor = (long)flt_scale; + base_context.scale_factor = (long)flt_scale; } - load_dists(10 * 1024 * 1024, &dbgen_ctx); // 10MiB + if (current_step >= children) { + return; + } + + load_dists(10 * 1024 * 1024, &base_context); // 10MiB /* have to do this after init */ tdefs[NATION].base = nations.count; tdefs[REGION].base = regions.count; auto &catalog = Catalog::GetCatalog(context, catalog_name); - auto append_info = duckdb::unique_ptr(new tpch_append_information[REGION + 1]); - memset(append_info.get(), 0, sizeof(tpch_append_information) * REGION + 1); - for (size_t i = PART; i <= REGION; i++) { - auto tname = get_table_name(i); - if (!tname.empty()) { - string full_tname = string(tname) + string(suffix); - auto &tbl_catalog = catalog.GetEntry(context, schema, full_tname); - append_info[i].appender = make_uniq(context, tbl_catalog); + TPCHDBgenParameters parameters(context, catalog, schema, suffix); +#ifndef DUCKDB_NO_THREADS + bool explicit_partial_generation = children > 1 && current_step != -1; + auto thread_count = TaskScheduler::GetScheduler(context).NumberOfThreads(); + if (explicit_partial_generation || thread_count <= 1) { +#endif + // if we are doing explicit partial generation the parallelism is managed outside of dbgen + // only generate the chunk we are interested in + TPCHDataAppender appender(context, parameters, base_context, BaseAppender::DEFAULT_FLUSH_COUNT); + appender.AppendData(children, current_step); + appender.Flush(); +#ifndef DUCKDB_NO_THREADS + } else { + // we split into 20 children per scale factor by default + static constexpr idx_t CHILDREN_PER_SCALE_FACTOR = 20; + idx_t child_count; + if (flt_scale < 1) { + child_count = 1; + } else { + child_count = MinValue(static_cast(CHILDREN_PER_SCALE_FACTOR * flt_scale), MAX_CHILDREN); } - } - - for (i = PART; i <= REGION; i++) { - if (table & (1 << i)) { - if (i < NATION) { - rowcnt = tdefs[i].base * dbgen_ctx.scale_factor; - } else { - rowcnt = tdefs[i].base; + idx_t step = 0; + vector finished_appenders; + while(step < child_count) { + // launch N threads + vector new_appenders; + vector threads; + idx_t launched_step = step; + // initialize the appenders for each thread + // note we prevent the threads themselves from flushing the appenders by specifying a very high flush count here + for(idx_t thr_idx = 0; thr_idx < thread_count && launched_step < child_count; thr_idx++, launched_step++) { + new_appenders.emplace_back(context, parameters, base_context, NumericLimits::Maximum()); } - if (children > 1 && current_step != -1) { - size_t part_size = std::ceil((double)rowcnt / (double)children); - auto part_offset = part_size * current_step; - auto part_end = part_offset + part_size; - rowcnt = part_end > rowcnt ? rowcnt - part_offset : part_size; - skip(i, children, part_offset, dbgen_ctx); - if (rowcnt > 0) { - // generate part of the table - gen_tbl(context, (int)i, rowcnt, append_info.get(), &dbgen_ctx, part_offset); - } - } else { - // generate full table - gen_tbl(context, (int)i, rowcnt, append_info.get(), &dbgen_ctx); + // launch the threads + for(idx_t thr_idx = 0; thr_idx < new_appenders.size(); thr_idx++) { + threads.emplace_back(ParallelTPCHAppend, &new_appenders[thr_idx], child_count, step); + step++; + } + // flush the previous batch of appenders while waiting (if any are there) + // now flush the appenders in-order + for(auto &appender : finished_appenders) { + appender.Flush(); + } + finished_appenders.clear(); + // wait for all threads to finish + for(auto &thread : threads) { + thread.join(); } + finished_appenders = std::move(new_appenders); } - } - // flush any incomplete chunks - for (size_t i = PART; i <= REGION; i++) { - if (append_info[i].appender) { - append_info[i].appender->Flush(); - append_info[i].appender.reset(); + // flush the final batch of appenders + for(auto &appender : finished_appenders) { + appender.Flush(); } } - +#endif cleanup_dists(); } diff --git a/extension/tpch/dbgen/include/dbgen/dss.h b/extension/tpch/dbgen/include/dbgen/dss.h index 34d7025f944..e26b6361be6 100644 --- a/extension/tpch/dbgen/include/dbgen/dss.h +++ b/extension/tpch/dbgen/include/dbgen/dss.h @@ -109,14 +109,12 @@ typedef struct { int count; int max; set_member *list; - long *permute; } distribution; /* * some handy access functions */ #define DIST_SIZE(d) d->count #define DIST_MEMBER(d, i) ((set_member *)((d)->list + i))->text -#define DIST_PERMUTE(d, i) (d->permute[i]) typedef struct { const char *name; @@ -152,7 +150,7 @@ long unjulian PROTO((long date)); long dssncasecmp PROTO((const char *s1, const char *s2, int n)); long dsscasecmp PROTO((const char *s1, const char *s2)); int pick_str PROTO((distribution * s, seed_t *seed, char *target)); -void agg_str PROTO((distribution * set, long count, seed_t *seed, char *dest)); +void agg_str PROTO((distribution * set, long count, seed_t *seed, char *dest, DBGenContext *ctx)); void read_dist PROTO((const char *path, const char *name, distribution *target)); void embed_str PROTO((distribution * d, int min, int max, int stream, char *dest)); #ifndef STDLIB_HAS_GETOPT @@ -216,8 +214,6 @@ EXTERN long verbose; EXTERN long force; EXTERN long updates; EXTERN long table; -EXTERN long children; -EXTERN int step; EXTERN int set_seeds; EXTERN char *d_path; @@ -483,6 +479,13 @@ int dbg_print(int dt, FILE *tgt, void *data, int len, int eol); #define BBB_OFFSET_SD 47 struct DBGenContext { + ~DBGenContext() { + if (permute) { + free(permute); + permute = NULL; + } + } + seed_t Seed[MAX_STREAM + 1] = { {PART, 1, 0, 1}, /* P_MFG_SD 0 */ {PART, 46831694, 0, 1}, /* P_BRND_SD 1 */ @@ -550,6 +553,7 @@ struct DBGenContext { }; long scale_factor = 1; + long *permute = NULL; }; #endif /* DSS_H */ diff --git a/extension/tpch/dbgen/permute.cpp b/extension/tpch/dbgen/permute.cpp index 6ef80d1afd6..396247bdb52 100644 --- a/extension/tpch/dbgen/permute.cpp +++ b/extension/tpch/dbgen/permute.cpp @@ -14,10 +14,11 @@ #include "dbgen/config.h" #include "dbgen/dss.h" +#include DSS_HUGE NextRand(DSS_HUGE seed); void permute(long *set, int cnt, seed_t *seed); -void permute_dist(distribution *d, seed_t *seed); +void permute_dist(distribution *d, seed_t *seed, DBGenContext *ctx); long seed; char *eol[2] = {" ", "},"}; @@ -27,8 +28,8 @@ char *eol[2] = {" ", "},"}; void permute(long *a, int c, seed_t *seed) { int i; - static DSS_HUGE source; - static long temp; + DSS_HUGE source; + long temp; if (a != (long *)NULL) { for (i = 0; i < c; i++) { @@ -42,17 +43,17 @@ void permute(long *a, int c, seed_t *seed) { return; } -void permute_dist(distribution *d, seed_t *seed) { +void permute_dist(distribution *d, seed_t *seed, DBGenContext *ctx) { int i; if (d != NULL) { - if (d->permute == (long *)NULL) { - d->permute = (long *)malloc(sizeof(long) * DIST_SIZE(d)); - MALLOC_CHECK(d->permute); + if (ctx->permute == (long *)NULL) { + ctx->permute = (long *)malloc(sizeof(long) * DIST_SIZE(d)); + MALLOC_CHECK(ctx->permute); } for (i = 0; i < DIST_SIZE(d); i++) - *(d->permute + i) = i; - permute(d->permute, DIST_SIZE(d), seed); + *(ctx->permute + i) = i; + permute(ctx->permute, DIST_SIZE(d), seed); } else INTERNAL_ERROR("Bad call to permute_dist"); diff --git a/scripts/format.py b/scripts/format.py index 3de5b4ada9c..8657eb775c4 100644 --- a/scripts/format.py +++ b/scripts/format.py @@ -116,10 +116,11 @@ check_only = True confirm = True silent = False +force = False def print_usage(): - print("Usage: python scripts/format.py [revision|--all] [--check|--fix]") + print("Usage: python scripts/format.py [revision|--all] [--check|--fix] [--force]") print( " [revision] is an optional revision number, all files that changed since that revision will be formatted (default=HEAD)" ) @@ -147,6 +148,8 @@ def print_usage(): confirm = True elif arg == '--silent': silent = True + elif arg == '--force': + force = True else: print_usage() @@ -169,9 +172,6 @@ def can_format_file(full_path): if not os.path.isfile(full_path): return False fname = full_path.split(os.path.sep)[-1] - # check ignored files - if file_is_ignored(full_path): - return False found = False # check file extension for ext in extensions: @@ -180,6 +180,9 @@ def can_format_file(full_path): break if not found: return False + # check ignored files + if file_is_ignored(full_path): + return False # now check file directory for dname in formatted_directories: if full_path.startswith(dname): @@ -262,8 +265,13 @@ def get_changed_files(revision): def get_formatted_text(f, full_path, directory, ext): if not can_format_file(full_path): - print("Eek, cannot format file " + full_path + " but attempted to format anyway") - exit(1) + if not force: + print( + "File " + + full_path + + " is not normally formatted - but attempted to format anyway. Use --force if formatting is desirable" + ) + exit(1) if f == 'list.hpp': # fill in list file file_list = [ diff --git a/scripts/reduce_sql.py b/scripts/reduce_sql.py index ab2cd70e96c..245a89b7b10 100644 --- a/scripts/reduce_sql.py +++ b/scripts/reduce_sql.py @@ -19,6 +19,28 @@ ''' +class MultiStatementManager: + delimiter = ';' + + def __init__(self, multi_statement): + # strip whitespace, then the final ';', and split on all ';' inbetween. + statements = list( + map(lambda x: x.strip(), multi_statement.strip().strip(';').split(MultiStatementManager.delimiter)) + ) + self.statements = [] + for stmt in statements: + if len(stmt) > 0: + self.statements.append(stmt.strip() + ";") + + def is_multi_statement(sql_statement): + if len(sql_statement.split(';')) > 1: + return True + return False + + def get_last_statement(self): + return self.statements[-1] + + def sanitize_error(err): err = re.sub(r'Error: near line \d+: ', '', err) err = err.replace(os.getcwd() + '/', '') @@ -192,7 +214,20 @@ def reduce_query_log_query(start, shell, queries, query_index, max_time_seconds) return sql_query -def reduce_query_log(queries, shell, max_time_seconds=300): +def reduce_multi_statement(sql_queries, local_shell, local_data_load): + reducer = MultiStatementManager(sql_queries) + last_statement = reducer.get_last_statement() + print(f"testing if just last statement of multi statement creates the error") + (stdout, stderr, returncode) = run_shell_command(local_shell, local_data_load + last_statement) + expected_error = sanitize_error(stderr).strip() + if len(expected_error) > 0: + # reduce just the last statement + return reduce(last_statement, local_data_load, local_shell, expected_error, int(args.max_time)) + queries = reduce_query_log(reducer.statements, local_shell, [local_data_load]) + return "\n".join(queries) + + +def reduce_query_log(queries, shell, data_load=[], max_time_seconds=300): start = time.time() current_index = 0 # first try to remove as many queries as possible @@ -203,8 +238,9 @@ def reduce_query_log(queries, shell, max_time_seconds=300): break # remove the query at "current_index" new_queries = queries[:current_index] + queries[current_index + 1 :] + new_queries_with_data = data_load + new_queries # try to run the queries and check if we still get the same error - (new_queries_x, current_error) = run_queries_until_crash(new_queries) + (new_queries_x, current_error) = run_queries_until_crash(new_queries_with_data) if current_error is None: # cannot remove this query without invalidating the test case current_index += 1 @@ -258,7 +294,11 @@ def reduce_query_log(queries, shell, max_time_seconds=300): print(expected_error) print("===================================================") - final_query = reduce(sql_query, data_load, shell, expected_error, int(args.max_time)) + if MultiStatementManager.is_multi_statement(sql_query): + final_query = reduce_multi_statement(sql_query, shell, data_load) + else: + final_query = reduce(sql_query, data_load, shell, expected_error, int(args.max_time)) + print("Found final reduced query") print("===================================================") print(final_query) diff --git a/scripts/run_fuzzer.py b/scripts/run_fuzzer.py index c7d096f11ed..f2bb8f326bf 100644 --- a/scripts/run_fuzzer.py +++ b/scripts/run_fuzzer.py @@ -13,6 +13,7 @@ db = None shell = None perform_checks = True +dry = False for param in sys.argv: if param == '--sqlsmith': fuzzer = 'sqlsmith' @@ -32,6 +33,8 @@ shell = param.replace('--shell=', '') elif param.startswith('--seed='): seed = int(param.replace('--seed=', '')) + elif param.startswith('--dry'): + dry = True if fuzzer is None: print("Unrecognized fuzzer to run, expected e.g. --sqlsmith or --duckfuzz") @@ -94,7 +97,11 @@ def run_shell_command(cmd): # first get a list of all github issues, and check if we can still reproduce them -current_errors = fuzzer_helper.extract_github_issues(shell, perform_checks) + +if dry: + current_errors = [] +else: + current_errors = fuzzer_helper.extract_github_issues(shell, perform_checks) max_queries = 2000 last_query_log_file = 'sqlsmith.log' @@ -148,11 +155,12 @@ def run_shell_command(cmd): with open(last_query_log_file, 'r') as f: last_query = f.read() -cmd = load_script + '\n' + last_query +with open(complete_log_file, 'r') as f: + all_queries = f.read() -(stdout, stderr, returncode) = run_shell_command(cmd) +(stdout, stderr, returncode) = run_shell_command(load_script + all_queries) if returncode == 0: - print("Failed to reproduce the issue with a single command...") + print("Failed to reproduce the issue...") exit(0) print("============== STDOUT ================") @@ -161,12 +169,11 @@ def run_shell_command(cmd): print(stderr) print("==========================================") if not fuzzer_helper.is_internal_error(stderr): - print("Failed to reproduce the internal error with a single command") + print("Failed to reproduce the internal error") exit(0) error_msg = reduce_sql.sanitize_error(stderr) - print("=========================================") print(" Reproduced successfully ") print("=========================================") @@ -180,14 +187,13 @@ def run_shell_command(cmd): ) exit(0) -print(last_query) - print("=========================================") print(" Attempting to reduce query ") print("=========================================") - # try to reduce the query as much as possible -last_query = reduce_sql.reduce(last_query, load_script, shell, error_msg) +# reduce_multi_statement checks just the last statement first as a heuristic to see if +# only the last statement causes the error. +required_queries = reduce_sql.reduce_multi_statement(all_queries, shell, load_script) cmd = load_script + '\n' + last_query + "\n" fuzzer_helper.file_issue(cmd, error_msg, fuzzer_name, seed, git_hash) diff --git a/scripts/run_sqlancer.py b/scripts/run_sqlancer.py index 61d4a13052d..2646de41fc9 100644 --- a/scripts/run_sqlancer.py +++ b/scripts/run_sqlancer.py @@ -120,7 +120,7 @@ print('----------------------------------------------') # clean up queries from the query log by trying to remove queries one by one -queries = reduce_sql.reduce_query_log(queries, shell) +queries = reduce_sql.reduce_query_log(queries, shell, []) reduced_test_case = ';\n'.join(queries) print('----------------------------------------------') diff --git a/scripts/run_tests_one_by_one.py b/scripts/run_tests_one_by_one.py index 9419a439356..863251f3a52 100644 --- a/scripts/run_tests_one_by_one.py +++ b/scripts/run_tests_one_by_one.py @@ -33,6 +33,7 @@ def valid_timeout(value): default=3600, type=valid_timeout, ) +parser.add_argument('--valgrind', action='store_true', help='Run the tests with valgrind', default=False) args, extra_args = parser.parse_known_args() @@ -127,9 +128,10 @@ def print_interval_background(interval): start = time.time() try: - res = subprocess.run( - [unittest_program, test_case], stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=timeout - ) + test_cmd = [unittest_program, test_case] + if args.valgrind: + test_cmd = ['valgrind'] + test_cmd + res = subprocess.run(test_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=timeout) except subprocess.TimeoutExpired as e: print(" (TIMED OUT)", flush=True) fail() diff --git a/scripts/sqllogictest/result.py b/scripts/sqllogictest/result.py index fff01070278..e71fc3fc653 100644 --- a/scripts/sqllogictest/result.py +++ b/scripts/sqllogictest/result.py @@ -432,24 +432,31 @@ def connect(self) -> SQLLogicConnectionPool: return SQLLogicConnectionPool(self.database.cursor()) +def is_regex(input: str) -> bool: + return input.startswith(":") or input.startswith(":") + + +def matches_regex(input: str, actual_str: str) -> bool: + if input.startswith(":"): + should_match = True + regex_str = input.replace(":", "") + else: + should_match = False + regex_str = input.replace(":", "") + re_options = re.DOTALL + re_pattern = re.compile(regex_str, re_options) + regex_matches = bool(re_pattern.fullmatch(actual_str)) + return regex_matches == should_match + + def compare_values(result: QueryResult, actual_str, expected_str, current_column): error = False if actual_str == expected_str: return True - if expected_str.startswith(":") or expected_str.startswith(":"): - if expected_str.startswith(":"): - should_match = True - regex_str = expected_str.replace(":", "") - else: - should_match = False - regex_str = expected_str.replace(":", "") - re_options = re.DOTALL - re_pattern = re.compile(regex_str, re_options) - regex_matches = bool(re_pattern.fullmatch(actual_str)) - if regex_matches == should_match: - return True + if is_regex(expected_str): + return matches_regex(expected_str, actual_str) sql_type = result.types[current_column] @@ -970,13 +977,19 @@ def execute_statement(self, statement: Statement): if expected_result.lines == None: return expected = '\n'.join(expected_result.lines) - # Sanitize the expected error - if expected.startswith('Dependency Error: '): - expected = expected.split('Dependency Error: ')[1] - if expected not in str(e): - self.fail( - f"Query failed, but did not produce the right error: {expected}\nInstead it produced: {str(e)}" - ) + if is_regex(expected): + if not matches_regex(expected, str(e)): + self.fail( + f"Query failed, but did not produce the right error: {expected}\nInstead it produced: {str(e)}" + ) + else: + # Sanitize the expected error + if expected.startswith('Dependency Error: '): + expected = expected.split('Dependency Error: ')[1] + if expected not in str(e): + self.fail( + f"Query failed, but did not produce the right error: {expected}\nInstead it produced: {str(e)}" + ) def check_require(self, statement: Require) -> RequireResult: not_an_extension = [ diff --git a/scripts/test_block_sizes.py b/scripts/test_block_sizes.py index 6f4dbc2fcc4..41db6646355 100644 --- a/scripts/test_block_sizes.py +++ b/scripts/test_block_sizes.py @@ -1,6 +1,4 @@ import os -import re -from python_helpers import open_utf8 def execute_system_command(cmd): @@ -11,14 +9,6 @@ def execute_system_command(cmd): raise Exception -def replace_in_file(fname, regex, replace): - with open_utf8(fname, 'r') as f: - contents = f.read() - contents = re.sub(regex, replace, contents) - with open_utf8(fname, 'w+') as f: - f.write(contents) - - current_dir = os.getcwd() build_dir = os.path.join(os.getcwd(), 'build', 'release') @@ -28,14 +18,8 @@ def replace_in_file(fname, regex, replace): print("TESTING BLOCK_ALLOC_SIZE=%d" % (block_size,)) print("TESTING STANDARD_VECTOR_SIZE") -replace_in_file( - 'src/include/duckdb/storage/storage_info.hpp', - r'constexpr static idx_t BLOCK_ALLOC_SIZE = \w+', - 'constexpr static idx_t BLOCK_ALLOC_SIZE = %d' % (block_size,), -) - execute_system_command('rm -rf build') -execute_system_command('make relassert') +execute_system_command(f'BLOCK_ALLOC_SIZE={block_size} make relassert') execute_system_command('build/relassert/test/unittest') execute_system_command('build/relassert/test/unittest "test/sql/storage/*"') @@ -45,12 +29,6 @@ def replace_in_file(fname, regex, replace): print("TESTING BLOCK_ALLOC_SIZE=%d" % (block_size,)) print("TESTING STANDARD_VECTOR_SIZE=%d" % (vector_size,)) -replace_in_file( - 'src/include/duckdb/common/vector_size.hpp', - r'#define STANDARD_VECTOR_SIZE \w+', - '#define STANDARD_VECTOR_SIZE %d' % (vector_size,), -) - execute_system_command('rm -rf build') -execute_system_command('make release') +execute_system_command(f'BLOCK_ALLOC_SIZE={block_size} STANDARD_VECTOR_SIZE={vector_size} make release') execute_system_command('build/release/test/unittest') diff --git a/scripts/test_vector_sizes.py b/scripts/test_vector_sizes.py index d2f267371c4..77ee50c27da 100644 --- a/scripts/test_vector_sizes.py +++ b/scripts/test_vector_sizes.py @@ -1,5 +1,4 @@ -import os, sys, re -from python_helpers import open_utf8 +import os vector_sizes = [2] @@ -15,21 +14,8 @@ def execute_system_command(cmd): raise Exception(f"Failed to run command {cmd} - exit code {retcode}") -def replace_in_file(fname, regex, replace): - with open_utf8(fname, 'r') as f: - contents = f.read() - contents = re.sub(regex, replace, contents) - with open_utf8(fname, 'w+') as f: - f.write(contents) - - for vector_size in vector_sizes: print("TESTING STANDARD_VECTOR_SIZE=%d" % (vector_size,)) - replace_in_file( - 'src/include/duckdb/common/vector_size.hpp', - r'#define STANDARD_VECTOR_SIZE \w+', - '#define STANDARD_VECTOR_SIZE %d' % (vector_size,), - ) execute_system_command('rm -rf build') - execute_system_command('make relassert') + execute_system_command(f'STANDARD_VECTOR_SIZE={vector_size} make relassert') execute_system_command('python3 scripts/run_tests_one_by_one.py build/relassert/test/unittest --no-exit') diff --git a/src/common/enum_util.cpp b/src/common/enum_util.cpp index 9f8e6c61005..5f69cfef214 100644 --- a/src/common/enum_util.cpp +++ b/src/common/enum_util.cpp @@ -81,6 +81,7 @@ #include "duckdb/execution/operator/csv_scanner/quote_rules.hpp" #include "duckdb/execution/reservoir_sample.hpp" #include "duckdb/function/aggregate_state.hpp" +#include "duckdb/function/copy_function.hpp" #include "duckdb/function/function.hpp" #include "duckdb/function/macro_function.hpp" #include "duckdb/function/scalar/compressed_materialization_functions.hpp" @@ -679,6 +680,8 @@ const char* EnumUtil::ToChars(BindingMode value) { return "STANDARD_BINDING"; case BindingMode::EXTRACT_NAMES: return "EXTRACT_NAMES"; + case BindingMode::EXTRACT_REPLACEMENT_SCANS: + return "EXTRACT_REPLACEMENT_SCANS"; default: throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value)); } @@ -692,6 +695,9 @@ BindingMode EnumUtil::FromString(const char *value) { if (StringUtil::Equals(value, "EXTRACT_NAMES")) { return BindingMode::EXTRACT_NAMES; } + if (StringUtil::Equals(value, "EXTRACT_REPLACEMENT_SCANS")) { + return BindingMode::EXTRACT_REPLACEMENT_SCANS; + } throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value)); } @@ -1353,6 +1359,29 @@ ConstraintType EnumUtil::FromString(const char *value) { throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value)); } +template<> +const char* EnumUtil::ToChars(CopyFunctionReturnType value) { + switch(value) { + case CopyFunctionReturnType::CHANGED_ROWS: + return "CHANGED_ROWS"; + case CopyFunctionReturnType::CHANGED_ROWS_AND_FILE_LIST: + return "CHANGED_ROWS_AND_FILE_LIST"; + default: + throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value)); + } +} + +template<> +CopyFunctionReturnType EnumUtil::FromString(const char *value) { + if (StringUtil::Equals(value, "CHANGED_ROWS")) { + return CopyFunctionReturnType::CHANGED_ROWS; + } + if (StringUtil::Equals(value, "CHANGED_ROWS_AND_FILE_LIST")) { + return CopyFunctionReturnType::CHANGED_ROWS_AND_FILE_LIST; + } + throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value)); +} + template<> const char* EnumUtil::ToChars(CopyOverwriteMode value) { switch(value) { @@ -1362,6 +1391,8 @@ const char* EnumUtil::ToChars(CopyOverwriteMode value) { return "COPY_OVERWRITE"; case CopyOverwriteMode::COPY_OVERWRITE_OR_IGNORE: return "COPY_OVERWRITE_OR_IGNORE"; + case CopyOverwriteMode::COPY_APPEND: + return "COPY_APPEND"; default: throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value)); } @@ -1378,6 +1409,9 @@ CopyOverwriteMode EnumUtil::FromString(const char *value) { if (StringUtil::Equals(value, "COPY_OVERWRITE_OR_IGNORE")) { return CopyOverwriteMode::COPY_OVERWRITE_OR_IGNORE; } + if (StringUtil::Equals(value, "COPY_APPEND")) { + return CopyOverwriteMode::COPY_APPEND; + } throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value)); } @@ -7089,6 +7123,34 @@ TimestampCastResult EnumUtil::FromString(const char *value) throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value)); } +template<> +const char* EnumUtil::ToChars(TransactionModifierType value) { + switch(value) { + case TransactionModifierType::TRANSACTION_DEFAULT_MODIFIER: + return "TRANSACTION_DEFAULT_MODIFIER"; + case TransactionModifierType::TRANSACTION_READ_ONLY: + return "TRANSACTION_READ_ONLY"; + case TransactionModifierType::TRANSACTION_READ_WRITE: + return "TRANSACTION_READ_WRITE"; + default: + throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value)); + } +} + +template<> +TransactionModifierType EnumUtil::FromString(const char *value) { + if (StringUtil::Equals(value, "TRANSACTION_DEFAULT_MODIFIER")) { + return TransactionModifierType::TRANSACTION_DEFAULT_MODIFIER; + } + if (StringUtil::Equals(value, "TRANSACTION_READ_ONLY")) { + return TransactionModifierType::TRANSACTION_READ_ONLY; + } + if (StringUtil::Equals(value, "TRANSACTION_READ_WRITE")) { + return TransactionModifierType::TRANSACTION_READ_WRITE; + } + throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value)); +} + template<> const char* EnumUtil::ToChars(TransactionType value) { switch(value) { diff --git a/src/common/file_system.cpp b/src/common/file_system.cpp index 27160adc3fa..166b2051797 100644 --- a/src/common/file_system.cpp +++ b/src/common/file_system.cpp @@ -21,6 +21,7 @@ #include #include #include +#include #include #include #include @@ -623,9 +624,14 @@ FileType FileHandle::GetType() { } bool FileSystem::IsRemoteFile(const string &path) { - const string prefixes[] = {"http://", "https://", "s3://", "s3a://", "s3n://", "gcs://", "gs://", "r2://", "hf://"}; - for (auto &prefix : prefixes) { - if (StringUtil::StartsWith(path, prefix)) { + string extension = ""; + return IsRemoteFile(path, extension); +} + +bool FileSystem::IsRemoteFile(const string &path, string &extension) { + for (const auto &entry : EXTENSION_FILE_PREFIXES) { + if (StringUtil::StartsWith(path, entry.name)) { + extension = entry.extension; return true; } } diff --git a/src/common/filename_pattern.cpp b/src/common/filename_pattern.cpp index 89cc6c63a75..04851ad3fba 100644 --- a/src/common/filename_pattern.cpp +++ b/src/common/filename_pattern.cpp @@ -10,6 +10,7 @@ void FilenamePattern::SetFilenamePattern(const string &pattern) { base = pattern; pos = base.find(id_format); + uuid = false; if (pos != string::npos) { base = StringUtil::Replace(base, id_format, ""); uuid = false; diff --git a/src/common/local_file_system.cpp b/src/common/local_file_system.cpp index e650d79bebb..99420fffbdf 100644 --- a/src/common/local_file_system.cpp +++ b/src/common/local_file_system.cpp @@ -29,6 +29,7 @@ #ifdef __MINGW32__ // need to manually define this for mingw extern "C" WINBASEAPI BOOL WINAPI GetPhysicallyInstalledSystemMemory(PULONGLONG); +extern "C" WINBASEAPI BOOL QueryFullProcessImageNameW(HANDLE, DWORD, LPWSTR, PDWORD); #endif #undef FILE_CREATE // woo mingw diff --git a/src/common/row_operations/row_matcher.cpp b/src/common/row_operations/row_matcher.cpp index 23b16946644..fe45a65d782 100644 --- a/src/common/row_operations/row_matcher.cpp +++ b/src/common/row_operations/row_matcher.cpp @@ -198,6 +198,22 @@ void RowMatcher::Initialize(const bool no_match_sel, const TupleDataLayout &layo } } +void RowMatcher::Initialize(const bool no_match_sel, const TupleDataLayout &layout, const Predicates &predicates, + vector &columns) { + + // The columns must have the same size as the predicates vector + D_ASSERT(columns.size() == predicates.size()); + + // The largest column_id must be smaller than the number of types to not cause an out-of-bounds error + D_ASSERT(*max_element(columns.begin(), columns.end()) < layout.GetTypes().size()); + + match_functions.reserve(predicates.size()); + for (idx_t idx = 0; idx < predicates.size(); idx++) { + column_t col_idx = columns[idx]; + match_functions.push_back(GetMatchFunction(no_match_sel, layout.GetTypes()[col_idx], predicates[idx])); + } +} + idx_t RowMatcher::Match(DataChunk &lhs, const vector &lhs_formats, SelectionVector &sel, idx_t count, const TupleDataLayout &rhs_layout, Vector &rhs_row_locations, SelectionVector *no_match_sel, idx_t &no_match_count) { @@ -211,6 +227,30 @@ idx_t RowMatcher::Match(DataChunk &lhs, const vector &lhs return count; } +idx_t RowMatcher::Match(DataChunk &lhs, const vector &lhs_formats, SelectionVector &sel, + idx_t count, const TupleDataLayout &rhs_layout, Vector &rhs_row_locations, + SelectionVector *no_match_sel, idx_t &no_match_count, const vector &columns) { + D_ASSERT(!match_functions.empty()); + + // The column_ids must have the same size as the match_functions vector + D_ASSERT(columns.size() == match_functions.size()); + + // The largest column_id must be smaller than the number columns to not cause an out-of-bounds error + D_ASSERT(*max_element(columns.begin(), columns.end()) < lhs.ColumnCount()); + + for (idx_t fun_idx = 0; fun_idx < match_functions.size(); fun_idx++) { + // if we only care about specific columns, we need to use the column_ids to get the correct column index + // otherwise, we just use the fun_idx + const auto col_idx = columns[fun_idx]; + + const auto &match_function = match_functions[fun_idx]; + count = + match_function.function(lhs.data[col_idx], lhs_formats[col_idx], sel, count, rhs_layout, rhs_row_locations, + col_idx, match_function.child_functions, no_match_sel, no_match_count); + } + return count; +} + MatchFunction RowMatcher::GetMatchFunction(const bool no_match_sel, const LogicalType &type, const ExpressionType predicate) { return no_match_sel ? GetMatchFunction(type, predicate) : GetMatchFunction(type, predicate); diff --git a/src/common/serializer/buffered_file_writer.cpp b/src/common/serializer/buffered_file_writer.cpp index be4f51fc3c7..aa572a9d189 100644 --- a/src/common/serializer/buffered_file_writer.cpp +++ b/src/common/serializer/buffered_file_writer.cpp @@ -65,6 +65,12 @@ void BufferedFileWriter::Flush() { offset = 0; } +void BufferedFileWriter::Close() { + Flush(); + handle->Close(); + handle.reset(); +} + void BufferedFileWriter::Sync() { Flush(); handle->Sync(); diff --git a/src/common/types/row/tuple_data_allocator.cpp b/src/common/types/row/tuple_data_allocator.cpp index cb6f0bb182d..02283b12a60 100644 --- a/src/common/types/row/tuple_data_allocator.cpp +++ b/src/common/types/row/tuple_data_allocator.cpp @@ -13,7 +13,7 @@ TupleDataBlock::TupleDataBlock(BufferManager &buffer_manager, idx_t capacity_p) buffer_manager.Allocate(MemoryTag::HASH_TABLE, capacity, false, &handle); } -TupleDataBlock::TupleDataBlock(TupleDataBlock &&other) noexcept { +TupleDataBlock::TupleDataBlock(TupleDataBlock &&other) noexcept : capacity(0), size(0) { std::swap(handle, other.handle); std::swap(capacity, other.capacity); std::swap(size, other.size); diff --git a/src/common/types/row/tuple_data_collection.cpp b/src/common/types/row/tuple_data_collection.cpp index 86cbb144c80..c5dfb71ea36 100644 --- a/src/common/types/row/tuple_data_collection.cpp +++ b/src/common/types/row/tuple_data_collection.cpp @@ -384,6 +384,17 @@ void TupleDataCollection::InitializeChunk(DataChunk &chunk) const { chunk.Initialize(allocator->GetAllocator(), layout.GetTypes()); } +void TupleDataCollection::InitializeChunk(DataChunk &chunk, const vector &columns) const { + vector chunk_types(columns.size()); + // keep the order of the columns + for (idx_t i = 0; i < columns.size(); i++) { + auto column_idx = columns[i]; + D_ASSERT(column_idx < layout.ColumnCount()); + chunk_types[i] = layout.GetTypes()[column_idx]; + } + chunk.Initialize(allocator->GetAllocator(), chunk_types); +} + void TupleDataCollection::InitializeScanChunk(TupleDataScanState &state, DataChunk &chunk) const { auto &column_ids = state.chunk_state.column_ids; D_ASSERT(!column_ids.empty()); diff --git a/src/common/types/selection_vector.cpp b/src/common/types/selection_vector.cpp index 8458d4c651b..b743c61fa1e 100644 --- a/src/common/types/selection_vector.cpp +++ b/src/common/types/selection_vector.cpp @@ -43,4 +43,19 @@ buffer_ptr SelectionVector::Slice(const SelectionVector &sel, idx return data; } +void SelectionVector::Verify(idx_t count, idx_t vector_size) const { +#ifdef DEBUG + D_ASSERT(vector_size >= 1); + for (idx_t i = 0; i < count; i++) { + auto index = get_index(i); + if (index >= vector_size) { + throw InternalException( + "Provided SelectionVector is invalid, index %d points to %d, which is out of range. " + "the valid range (0-%d)", + i, index, vector_size - 1); + } + } +#endif +} + } // namespace duckdb diff --git a/src/common/types/value.cpp b/src/common/types/value.cpp index 9fae9858d28..999a17b35f1 100644 --- a/src/common/types/value.cpp +++ b/src/common/types/value.cpp @@ -346,8 +346,10 @@ Value Value::MaximumValue(const LogicalType &type) { throw InternalException("Unknown decimal type"); } } - case LogicalTypeId::ENUM: - return Value::ENUM(EnumType::GetSize(type) - 1, type); + case LogicalTypeId::ENUM: { + auto enum_size = EnumType::GetSize(type); + return Value::ENUM(enum_size - (enum_size ? 1 : 0), type); + } default: throw InvalidTypeException(type, "MaximumValue requires numeric type"); } diff --git a/src/common/types/vector.cpp b/src/common/types/vector.cpp index aa08072ac55..662152704d9 100644 --- a/src/common/types/vector.cpp +++ b/src/common/types/vector.cpp @@ -30,7 +30,7 @@ namespace duckdb { UnifiedVectorFormat::UnifiedVectorFormat() : sel(nullptr), data(nullptr) { } -UnifiedVectorFormat::UnifiedVectorFormat(UnifiedVectorFormat &&other) noexcept { +UnifiedVectorFormat::UnifiedVectorFormat(UnifiedVectorFormat &&other) noexcept : sel(nullptr), data(nullptr) { bool refers_to_self = other.sel == &other.owned_sel; std::swap(sel, other.sel); std::swap(data, other.data); @@ -860,7 +860,10 @@ void Vector::Flatten(idx_t count) { // constant NULL, set nullmask validity.EnsureWritable(); validity.SetAllInvalid(count); - return; + if (GetType().InternalType() != PhysicalType::STRUCT) { + // for structs we still need to flatten the child vectors as well + return; + } } // non-null constant: have to repeat the constant switch (GetType().InternalType()) { @@ -1155,8 +1158,13 @@ void Vector::Serialize(Serializer &serializer, idx_t count) { for (idx_t i = 0; i < count; i++) { auto idx = vdata.sel->get_index(i); auto source = source_array[idx]; - entries[i].offset = source.offset; - entries[i].length = source.length; + if (vdata.validity.RowIsValid(idx)) { + entries[i].offset = source.offset; + entries[i].length = source.length; + } else { + entries[i].offset = 0; + entries[i].length = 0; + } } serializer.WriteProperty(104, "list_size", list_size); serializer.WriteList(105, "entries", count, [&](Serializer::List &list, idx_t i) { diff --git a/src/core_functions/aggregate/distributive/approx_count.cpp b/src/core_functions/aggregate/distributive/approx_count.cpp index 6b8dd0d7c66..f9479f179c3 100644 --- a/src/core_functions/aggregate/distributive/approx_count.cpp +++ b/src/core_functions/aggregate/distributive/approx_count.cpp @@ -5,109 +5,165 @@ #include "duckdb/function/function_set.hpp" #include "duckdb/planner/expression/bound_aggregate_expression.hpp" +#include "hyperloglog.hpp" + +#include + namespace duckdb { +// Algorithms from +// "New cardinality estimation algorithms for HyperLogLog sketches" +// Otmar Ertl, arXiv:1702.01284 struct ApproxDistinctCountState { - ApproxDistinctCountState() : log(nullptr) { + static constexpr idx_t P = 6; + static constexpr idx_t Q = 64 - P; + static constexpr idx_t M = 1 << P; + static constexpr double ALPHA = 0.721347520444481703680; // 1 / (2 log(2)) + + ApproxDistinctCountState() { + ::memset(k, 0, sizeof(k)); + } + + //! Taken from https://stackoverflow.com/a/72088344 + static inline uint8_t CountTrailingZeros(const uint64_t &x) { + static constexpr const uint64_t DEBRUIJN = 0x03f79d71b4cb0a89; + static constexpr const uint8_t LOOKUP[] = {0, 47, 1, 56, 48, 27, 2, 60, 57, 49, 41, 37, 28, 16, 3, 61, + 54, 58, 35, 52, 50, 42, 21, 44, 38, 32, 29, 23, 17, 11, 4, 62, + 46, 55, 26, 59, 40, 36, 15, 53, 34, 51, 20, 43, 31, 22, 10, 45, + 25, 39, 14, 33, 19, 30, 9, 24, 13, 18, 8, 12, 7, 6, 5, 63}; + return LOOKUP[(DEBRUIJN * (x ^ (x - 1))) >> 58]; + } + + inline void Update(const idx_t &i, const uint8_t &z) { + k[i] = MaxValue(k[i], z); + } + + //! Algorithm 1 + inline void InsertElement(hash_t h) { + const auto i = h & ((1 << P) - 1); + h >>= P; + h |= hash_t(1) << Q; + const uint8_t z = CountTrailingZeros(h) + 1; + Update(i, z); } - ~ApproxDistinctCountState() { - if (log) { - delete log; + + //! Algorithm 2 + inline void Merge(const ApproxDistinctCountState &other) { + for (idx_t i = 0; i < M; ++i) { + Update(i, other.k[i]); } } - HyperLogLog *log; + //! Algorithm 4 + void ExtractCounts(uint32_t *c) const { + for (idx_t i = 0; i < M; ++i) { + c[k[i]]++; + } + } + + //! Algorithm 6 + static int64_t EstimateCardinality(uint32_t *c) { + auto z = M * duckdb_hll::hllTau((M - c[Q]) / double(M)); + + for (idx_t k = Q; k >= 1; --k) { + z += c[k]; + z *= 0.5; + } + + z += M * duckdb_hll::hllSigma(c[0] / double(M)); + + return llroundl(ALPHA * M * M / z); + } + + idx_t Count() const { + uint32_t c[Q + 2] = {0}; + ExtractCounts(c); + return idx_t(EstimateCardinality(c)); + } + + uint8_t k[M]; }; struct ApproxCountDistinctFunction { template static void Initialize(STATE &state) { - state.log = nullptr; + new (&state) STATE(); } template static void Combine(const STATE &source, STATE &target, AggregateInputData &) { - if (!source.log) { - return; - } - if (!target.log) { - target.log = new HyperLogLog(); - } - D_ASSERT(target.log); - D_ASSERT(source.log); - auto new_log = target.log->MergePointer(*source.log); - delete target.log; - target.log = new_log; + target.Merge(source); } template static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) { - if (state.log) { - target = UnsafeNumericCast(state.log->Count()); - } else { - target = 0; - } + target = UnsafeNumericCast(state.Count()); } static bool IgnoreNull() { return true; } - - template - static void Destroy(STATE &state, AggregateInputData &aggr_input_data) { - if (state.log) { - delete state.log; - state.log = nullptr; - } - } }; static void ApproxCountDistinctSimpleUpdateFunction(Vector inputs[], AggregateInputData &, idx_t input_count, data_ptr_t state, idx_t count) { D_ASSERT(input_count == 1); + auto &input = inputs[0]; + UnifiedVectorFormat idata; + input.ToUnifiedFormat(count, idata); - auto agg_state = reinterpret_cast(state); - if (!agg_state->log) { - agg_state->log = new HyperLogLog(); + if (count > STANDARD_VECTOR_SIZE) { + throw InternalException("ApproxCountDistinct - count must be at most vector size"); } + Vector hash_vec(LogicalType::HASH, count); + VectorOperations::Hash(input, hash_vec, count); - UnifiedVectorFormat vdata; - inputs[0].ToUnifiedFormat(count, vdata); + UnifiedVectorFormat hdata; + hash_vec.ToUnifiedFormat(count, hdata); + const auto *hashes = UnifiedVectorFormat::GetData(hdata); + auto agg_state = reinterpret_cast(state); - if (count > STANDARD_VECTOR_SIZE) { - throw InternalException("ApproxCountDistinct - count must be at most vector size"); + if (hash_vec.GetVectorType() == VectorType::CONSTANT_VECTOR) { + if (idata.validity.RowIsValid(0)) { + agg_state->InsertElement(hashes[0]); + } + } else { + for (idx_t i = 0; i < count; ++i) { + if (idata.validity.RowIsValid(idata.sel->get_index(i))) { + const auto hash = hashes[hdata.sel->get_index(i)]; + agg_state->InsertElement(hash); + } + } } - uint64_t indices[STANDARD_VECTOR_SIZE]; - uint8_t counts[STANDARD_VECTOR_SIZE]; - HyperLogLog::ProcessEntries(vdata, inputs[0].GetType(), indices, counts, count); - agg_state->log->AddToLog(vdata, count, indices, counts); } static void ApproxCountDistinctUpdateFunction(Vector inputs[], AggregateInputData &, idx_t input_count, Vector &state_vector, idx_t count) { D_ASSERT(input_count == 1); + auto &input = inputs[0]; + UnifiedVectorFormat idata; + input.ToUnifiedFormat(count, idata); + + if (count > STANDARD_VECTOR_SIZE) { + throw InternalException("ApproxCountDistinct - count must be at most vector size"); + } + Vector hash_vec(LogicalType::HASH, count); + VectorOperations::Hash(input, hash_vec, count); UnifiedVectorFormat sdata; state_vector.ToUnifiedFormat(count, sdata); - auto states = UnifiedVectorFormat::GetDataNoConst(sdata); + const auto states = UnifiedVectorFormat::GetDataNoConst(sdata); + UnifiedVectorFormat hdata; + hash_vec.ToUnifiedFormat(count, hdata); + const auto *hashes = UnifiedVectorFormat::GetData(hdata); for (idx_t i = 0; i < count; i++) { - auto agg_state = states[sdata.sel->get_index(i)]; - if (!agg_state->log) { - agg_state->log = new HyperLogLog(); + if (idata.validity.RowIsValid(idata.sel->get_index(i))) { + auto agg_state = states[sdata.sel->get_index(i)]; + const auto hash = hashes[hdata.sel->get_index(i)]; + agg_state->InsertElement(hash); } } - - UnifiedVectorFormat vdata; - inputs[0].ToUnifiedFormat(count, vdata); - - if (count > STANDARD_VECTOR_SIZE) { - throw InternalException("ApproxCountDistinct - count must be at most vector size"); - } - uint64_t indices[STANDARD_VECTOR_SIZE]; - uint8_t counts[STANDARD_VECTOR_SIZE]; - HyperLogLog::ProcessEntries(vdata, inputs[0].GetType(), indices, counts, count); - HyperLogLog::AddToLogs(vdata, count, indices, counts, reinterpret_cast(states), sdata.sel); } AggregateFunction GetApproxCountDistinctFunction(const LogicalType &input_type) { @@ -117,30 +173,13 @@ AggregateFunction GetApproxCountDistinctFunction(const LogicalType &input_type) ApproxCountDistinctUpdateFunction, AggregateFunction::StateCombine, AggregateFunction::StateFinalize, - ApproxCountDistinctSimpleUpdateFunction, nullptr, - AggregateFunction::StateDestroy); + ApproxCountDistinctSimpleUpdateFunction); fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING; return fun; } -AggregateFunctionSet ApproxCountDistinctFun::GetFunctions() { - AggregateFunctionSet approx_count("approx_count_distinct"); - approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::UTINYINT)); - approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::USMALLINT)); - approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::UINTEGER)); - approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::UBIGINT)); - approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::UHUGEINT)); - approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::TINYINT)); - approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::SMALLINT)); - approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::BIGINT)); - approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::HUGEINT)); - approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::FLOAT)); - approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::DOUBLE)); - approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::TIMESTAMP)); - approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::TIMESTAMP_TZ)); - approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::BLOB)); - approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::ANY_PARAMS(LogicalType::VARCHAR, 150))); - return approx_count; +AggregateFunction ApproxCountDistinctFun::GetFunction() { + return GetApproxCountDistinctFunction(LogicalType::ANY); } } // namespace duckdb diff --git a/src/core_functions/aggregate/distributive/arg_min_max.cpp b/src/core_functions/aggregate/distributive/arg_min_max.cpp index c39b0599961..6feffca464c 100644 --- a/src/core_functions/aggregate/distributive/arg_min_max.cpp +++ b/src/core_functions/aggregate/distributive/arg_min_max.cpp @@ -164,7 +164,7 @@ struct ArgMinMaxBase { if (!state.is_initialized || state.arg_null) { finalize_data.ReturnNull(); } else { - STATE::template ReadValue(finalize_data.result, state.arg, target); + STATE::template ReadValue(finalize_data.result, state.arg, target); } } @@ -248,7 +248,7 @@ struct VectorArgMinMaxBase : ArgMinMaxBase { return; } if (!target.is_initialized || COMPARATOR::Operation(source.value, target.value)) { - STATE::template AssignValue(target.value, source.value); + STATE::template AssignValue(target.value, source.value); AssignVector(target, *source.arg, source.arg_null, 0); target.is_initialized = true; } diff --git a/src/core_functions/aggregate/distributive/bitagg.cpp b/src/core_functions/aggregate/distributive/bitagg.cpp index 2d57a4f548c..af3056359ac 100644 --- a/src/core_functions/aggregate/distributive/bitagg.cpp +++ b/src/core_functions/aggregate/distributive/bitagg.cpp @@ -53,10 +53,10 @@ struct BitwiseOperation { template static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &) { if (!state.is_set) { - OP::template Assign(state, input); + OP::template Assign(state, input); state.is_set = true; } else { - OP::template Execute(state, input); + OP::template Execute(state, input); } } @@ -79,10 +79,10 @@ struct BitwiseOperation { } if (!target.is_set) { // target is NULL, use source value directly. - OP::template Assign(target, source.value); + OP::template Assign(target, source.value); target.is_set = true; } else { - OP::template Execute(target, source.value); + OP::template Execute(target, source.value); } } diff --git a/src/core_functions/aggregate/distributive/functions.json b/src/core_functions/aggregate/distributive/functions.json index 3bdfe3446fb..f128069b25b 100644 --- a/src/core_functions/aggregate/distributive/functions.json +++ b/src/core_functions/aggregate/distributive/functions.json @@ -1,10 +1,10 @@ [ { "name": "approx_count_distinct", - "parameters": "x", + "parameters": "any", "description": "Computes the approximate count of distinct elements using HyperLogLog.", "example": "approx_count_distinct(A)", - "type": "aggregate_function_set" + "type": "aggregate_function" }, { "name": "arg_min", diff --git a/src/core_functions/aggregate/distributive/minmax.cpp b/src/core_functions/aggregate/distributive/minmax.cpp index d3a5dd49c68..0e40b45d054 100644 --- a/src/core_functions/aggregate/distributive/minmax.cpp +++ b/src/core_functions/aggregate/distributive/minmax.cpp @@ -487,7 +487,7 @@ struct VectorMinMaxBase { if (!state.value) { Assign(state, input, i); } else { - OP::template Execute(state, input, i, count); + OP::template Execute(state, input, i, count); } } } @@ -499,7 +499,7 @@ struct VectorMinMaxBase { } else if (!target.value) { Assign(target, *source.value, 0); } else { - OP::template Execute(target, *source.value, 0, 1); + OP::template Execute(target, *source.value, 0, 1); } } diff --git a/src/core_functions/function_list.cpp b/src/core_functions/function_list.cpp index e62330b50c3..e43904f2dab 100644 --- a/src/core_functions/function_list.cpp +++ b/src/core_functions/function_list.cpp @@ -65,7 +65,7 @@ static const StaticFunctionDefinition internal_functions[] = { DUCKDB_SCALAR_FUNCTION_ALIAS(AggregateFun), DUCKDB_SCALAR_FUNCTION(AliasFun), DUCKDB_SCALAR_FUNCTION_ALIAS(ApplyFun), - DUCKDB_AGGREGATE_FUNCTION_SET(ApproxCountDistinctFun), + DUCKDB_AGGREGATE_FUNCTION(ApproxCountDistinctFun), DUCKDB_AGGREGATE_FUNCTION_SET(ApproxQuantileFun), DUCKDB_AGGREGATE_FUNCTION_SET(ArgMaxFun), DUCKDB_AGGREGATE_FUNCTION_SET(ArgMaxNullFun), diff --git a/src/core_functions/scalar/list/array_slice.cpp b/src/core_functions/scalar/list/array_slice.cpp index 8075aeeaa07..3cc0960d96a 100644 --- a/src/core_functions/scalar/list/array_slice.cpp +++ b/src/core_functions/scalar/list/array_slice.cpp @@ -42,7 +42,7 @@ unique_ptr ListSliceBindData::Copy() const { template static idx_t CalculateSliceLength(idx_t begin, idx_t end, INDEX_TYPE step, bool svalid) { if (step < 0) { - step = abs(step); + step = AbsValue(step); } if (step == 0 && svalid) { throw InvalidInputException("Slice step cannot be zero"); diff --git a/src/core_functions/scalar/list/list_sort.cpp b/src/core_functions/scalar/list/list_sort.cpp index f206c509323..0fbe54ba999 100644 --- a/src/core_functions/scalar/list/list_sort.cpp +++ b/src/core_functions/scalar/list/list_sort.cpp @@ -130,8 +130,6 @@ static void ListSortFunction(DataChunk &args, ExpressionState &state, Vector &re // get the child vector auto lists_size = ListVector::GetListSize(sort_result_vec); auto &child_vector = ListVector::GetEntry(sort_result_vec); - UnifiedVectorFormat child_data; - child_vector.ToUnifiedFormat(lists_size, child_data); // get the lists data UnifiedVectorFormat lists_data; diff --git a/src/core_functions/scalar/string/reverse.cpp b/src/core_functions/scalar/string/reverse.cpp index 95c3cf1a0cc..cef1441fa00 100644 --- a/src/core_functions/scalar/string/reverse.cpp +++ b/src/core_functions/scalar/string/reverse.cpp @@ -3,7 +3,7 @@ #include "duckdb/common/exception.hpp" #include "duckdb/common/vector_operations/vector_operations.hpp" #include "duckdb/common/vector_operations/unary_executor.hpp" -#include "utf8proc.hpp" +#include "utf8proc_wrapper.hpp" #include @@ -23,10 +23,9 @@ static bool StrReverseASCII(const char *input, idx_t n, char *output) { //! Unicode string reverse using grapheme breakers static void StrReverseUnicode(const char *input, idx_t n, char *output) { - utf8proc_grapheme_callback(input, n, [&](size_t start, size_t end) { - memcpy(output + n - end, input + start, end - start); - return true; - }); + for (auto cluster : Utf8Proc::GraphemeClusters(input, n)) { + memcpy(output + n - cluster.end, input + cluster.start, cluster.end - cluster.start); + } } struct ReverseOperator { diff --git a/src/execution/aggregate_hashtable.cpp b/src/execution/aggregate_hashtable.cpp index 5e944fba7f9..4e141644685 100644 --- a/src/execution/aggregate_hashtable.cpp +++ b/src/execution/aggregate_hashtable.cpp @@ -9,6 +9,7 @@ #include "duckdb/common/types/row/tuple_data_iterator.hpp" #include "duckdb/common/vector_operations/vector_operations.hpp" #include "duckdb/execution/expression_executor.hpp" +#include "duckdb/execution/ht_entry.hpp" #include "duckdb/planner/expression/bound_aggregate_expression.hpp" namespace duckdb { @@ -146,7 +147,7 @@ void GroupedAggregateHashTable::Verify() { continue; } auto hash = Load(entry.GetPointer() + hash_offset); - D_ASSERT(entry.GetSalt() == aggr_ht_entry_t::ExtractSalt(hash)); + D_ASSERT(entry.GetSalt() == ht_entry_t::ExtractSalt(hash)); total_count++; } D_ASSERT(total_count == Count()); @@ -154,7 +155,7 @@ void GroupedAggregateHashTable::Verify() { } void GroupedAggregateHashTable::ClearPointerTable() { - std::fill_n(entries, capacity, aggr_ht_entry_t(0)); + std::fill_n(entries, capacity, ht_entry_t::GetEmptyEntry()); } void GroupedAggregateHashTable::ResetCount() { @@ -173,8 +174,8 @@ void GroupedAggregateHashTable::Resize(idx_t size) { } capacity = size; - hash_map = buffer_manager.GetBufferAllocator().Allocate(capacity * sizeof(aggr_ht_entry_t)); - entries = reinterpret_cast(hash_map.get()); + hash_map = buffer_manager.GetBufferAllocator().Allocate(capacity * sizeof(ht_entry_t)); + entries = reinterpret_cast(hash_map.get()); ClearPointerTable(); bitmask = capacity - 1; @@ -201,7 +202,7 @@ void GroupedAggregateHashTable::Resize(idx_t size) { } auto &entry = entries[entry_idx]; D_ASSERT(!entry.IsOccupied()); - entry.SetSalt(aggr_ht_entry_t::ExtractSalt(hash)); + entry.SetSalt(ht_entry_t::ExtractSalt(hash)); entry.SetPointer(row_location); D_ASSERT(entry.IsOccupied()); } @@ -333,7 +334,7 @@ idx_t GroupedAggregateHashTable::FindOrCreateGroupsInternal(DataChunk &groups, V const auto &hash = hashes[r]; ht_offsets[r] = ApplyBitMask(hash); D_ASSERT(ht_offsets[r] == hash % capacity); - hash_salts[r] = aggr_ht_entry_t::ExtractSalt(hash); + hash_salts[r] = ht_entry_t::ExtractSalt(hash); } // we start out with all entries [0, 1, 2, ..., groups.size()] diff --git a/src/execution/index/art/art.cpp b/src/execution/index/art/art.cpp index a28a0f66455..974a7ec1167 100644 --- a/src/execution/index/art/art.cpp +++ b/src/execution/index/art/art.cpp @@ -213,139 +213,153 @@ unique_ptr ART::TryInitializeScan(const Transaction &transaction // Keys //===--------------------------------------------------------------------===// -template +template static void TemplatedGenerateKeys(ArenaAllocator &allocator, Vector &input, idx_t count, vector &keys) { - UnifiedVectorFormat idata; - input.ToUnifiedFormat(count, idata); D_ASSERT(keys.size() >= count); + UnifiedVectorFormat idata; + input.ToUnifiedFormat(count, idata); auto input_data = UnifiedVectorFormat::GetData(idata); + for (idx_t i = 0; i < count; i++) { auto idx = idata.sel->get_index(i); - if (idata.validity.RowIsValid(idx)) { + + if (IS_NOT_NULL || idata.validity.RowIsValid(idx)) { ARTKey::CreateARTKey(allocator, input.GetType(), keys[i], input_data[idx]); - } else { - // we need to possibly reset the former key value in the keys vector - keys[i] = ARTKey(); + continue; } + + // We need to reset the key value in the reusable keys vector. + keys[i] = ARTKey(); } } -template +template static void ConcatenateKeys(ArenaAllocator &allocator, Vector &input, idx_t count, vector &keys) { + UnifiedVectorFormat idata; input.ToUnifiedFormat(count, idata); - auto input_data = UnifiedVectorFormat::GetData(idata); + for (idx_t i = 0; i < count; i++) { auto idx = idata.sel->get_index(i); - // key is not NULL (no previous column entry was NULL) - if (!keys[i].Empty()) { - if (!idata.validity.RowIsValid(idx)) { - // this column entry is NULL, set whole key to NULL - keys[i] = ARTKey(); - } else { - auto other_key = ARTKey::CreateARTKey(allocator, input.GetType(), input_data[idx]); - keys[i].ConcatenateARTKey(allocator, other_key); - } + if (IS_NOT_NULL) { + auto other_key = ARTKey::CreateARTKey(allocator, input.GetType(), input_data[idx]); + keys[i].ConcatenateARTKey(allocator, other_key); + continue; + } + + // A previous column entry was NULL. + if (keys[i].Empty()) { + continue; + } + + // This column entry is NULL, so we set the whole key to NULL. + if (!idata.validity.RowIsValid(idx)) { + keys[i] = ARTKey(); + continue; } + + // Concatenate the keys. + auto other_key = ARTKey::CreateARTKey(allocator, input.GetType(), input_data[idx]); + keys[i].ConcatenateARTKey(allocator, other_key); } } -void ART::GenerateKeys(ArenaAllocator &allocator, DataChunk &input, vector &keys) { - // generate keys for the first input column +template +void GenerateKeysInternal(ArenaAllocator &allocator, DataChunk &input, vector &keys) { switch (input.data[0].GetType().InternalType()) { case PhysicalType::BOOL: - TemplatedGenerateKeys(allocator, input.data[0], input.size(), keys); + TemplatedGenerateKeys(allocator, input.data[0], input.size(), keys); break; case PhysicalType::INT8: - TemplatedGenerateKeys(allocator, input.data[0], input.size(), keys); + TemplatedGenerateKeys(allocator, input.data[0], input.size(), keys); break; case PhysicalType::INT16: - TemplatedGenerateKeys(allocator, input.data[0], input.size(), keys); + TemplatedGenerateKeys(allocator, input.data[0], input.size(), keys); break; case PhysicalType::INT32: - TemplatedGenerateKeys(allocator, input.data[0], input.size(), keys); + TemplatedGenerateKeys(allocator, input.data[0], input.size(), keys); break; case PhysicalType::INT64: - TemplatedGenerateKeys(allocator, input.data[0], input.size(), keys); + TemplatedGenerateKeys(allocator, input.data[0], input.size(), keys); break; case PhysicalType::INT128: - TemplatedGenerateKeys(allocator, input.data[0], input.size(), keys); + TemplatedGenerateKeys(allocator, input.data[0], input.size(), keys); break; case PhysicalType::UINT8: - TemplatedGenerateKeys(allocator, input.data[0], input.size(), keys); + TemplatedGenerateKeys(allocator, input.data[0], input.size(), keys); break; case PhysicalType::UINT16: - TemplatedGenerateKeys(allocator, input.data[0], input.size(), keys); + TemplatedGenerateKeys(allocator, input.data[0], input.size(), keys); break; case PhysicalType::UINT32: - TemplatedGenerateKeys(allocator, input.data[0], input.size(), keys); + TemplatedGenerateKeys(allocator, input.data[0], input.size(), keys); break; case PhysicalType::UINT64: - TemplatedGenerateKeys(allocator, input.data[0], input.size(), keys); + TemplatedGenerateKeys(allocator, input.data[0], input.size(), keys); break; case PhysicalType::UINT128: - TemplatedGenerateKeys(allocator, input.data[0], input.size(), keys); + TemplatedGenerateKeys(allocator, input.data[0], input.size(), keys); break; case PhysicalType::FLOAT: - TemplatedGenerateKeys(allocator, input.data[0], input.size(), keys); + TemplatedGenerateKeys(allocator, input.data[0], input.size(), keys); break; case PhysicalType::DOUBLE: - TemplatedGenerateKeys(allocator, input.data[0], input.size(), keys); + TemplatedGenerateKeys(allocator, input.data[0], input.size(), keys); break; case PhysicalType::VARCHAR: - TemplatedGenerateKeys(allocator, input.data[0], input.size(), keys); + TemplatedGenerateKeys(allocator, input.data[0], input.size(), keys); break; default: throw InternalException("Invalid type for index"); } + // We concatenate the keys for each remaining column of a compound key. for (idx_t i = 1; i < input.ColumnCount(); i++) { - // for each of the remaining columns, concatenate switch (input.data[i].GetType().InternalType()) { case PhysicalType::BOOL: - ConcatenateKeys(allocator, input.data[i], input.size(), keys); + ConcatenateKeys(allocator, input.data[i], input.size(), keys); break; case PhysicalType::INT8: - ConcatenateKeys(allocator, input.data[i], input.size(), keys); + ConcatenateKeys(allocator, input.data[i], input.size(), keys); break; case PhysicalType::INT16: - ConcatenateKeys(allocator, input.data[i], input.size(), keys); + ConcatenateKeys(allocator, input.data[i], input.size(), keys); break; case PhysicalType::INT32: - ConcatenateKeys(allocator, input.data[i], input.size(), keys); + ConcatenateKeys(allocator, input.data[i], input.size(), keys); break; case PhysicalType::INT64: - ConcatenateKeys(allocator, input.data[i], input.size(), keys); + ConcatenateKeys(allocator, input.data[i], input.size(), keys); break; case PhysicalType::INT128: - ConcatenateKeys(allocator, input.data[i], input.size(), keys); + ConcatenateKeys(allocator, input.data[i], input.size(), keys); break; case PhysicalType::UINT8: - ConcatenateKeys(allocator, input.data[i], input.size(), keys); + ConcatenateKeys(allocator, input.data[i], input.size(), keys); break; case PhysicalType::UINT16: - ConcatenateKeys(allocator, input.data[i], input.size(), keys); + ConcatenateKeys(allocator, input.data[i], input.size(), keys); break; case PhysicalType::UINT32: - ConcatenateKeys(allocator, input.data[i], input.size(), keys); + ConcatenateKeys(allocator, input.data[i], input.size(), keys); break; case PhysicalType::UINT64: - ConcatenateKeys(allocator, input.data[i], input.size(), keys); + ConcatenateKeys(allocator, input.data[i], input.size(), keys); break; case PhysicalType::UINT128: - ConcatenateKeys(allocator, input.data[i], input.size(), keys); + ConcatenateKeys(allocator, input.data[i], input.size(), keys); break; case PhysicalType::FLOAT: - ConcatenateKeys(allocator, input.data[i], input.size(), keys); + ConcatenateKeys(allocator, input.data[i], input.size(), keys); break; case PhysicalType::DOUBLE: - ConcatenateKeys(allocator, input.data[i], input.size(), keys); + ConcatenateKeys(allocator, input.data[i], input.size(), keys); break; case PhysicalType::VARCHAR: - ConcatenateKeys(allocator, input.data[i], input.size(), keys); + ConcatenateKeys(allocator, input.data[i], input.size(), keys); break; default: throw InternalException("Invalid type for index"); @@ -353,6 +367,16 @@ void ART::GenerateKeys(ArenaAllocator &allocator, DataChunk &input, vector +void ART::GenerateKeys<>(ArenaAllocator &allocator, DataChunk &input, vector &keys) { + GenerateKeysInternal(allocator, input, keys); +} + +template <> +void ART::GenerateKeys(ArenaAllocator &allocator, DataChunk &input, vector &keys) { + GenerateKeysInternal(allocator, input, keys); +} + //===--------------------------------------------------------------------===// // Construct from sorted data (only during CREATE (UNIQUE) INDEX statements) //===--------------------------------------------------------------------===// @@ -380,8 +404,8 @@ void GetChildSections(vector &child_sections, vector &keys, child_sections.emplace_back(child_start_idx, key_section.end, keys, key_section); } -bool Construct(ART &art, vector &keys, row_t *row_ids, Node &node, KeySection &key_section, - bool &has_constraint) { +bool ConstructInternal(ART &art, vector &keys, const row_t *row_ids, Node &node, KeySection &key_section, + bool &has_constraint) { D_ASSERT(key_section.start < keys.size()); D_ASSERT(key_section.end < keys.size()); @@ -438,7 +462,7 @@ bool Construct(ART &art, vector &keys, row_t *row_ids, Node &node, KeySe // recurse on each child section for (auto &child_section : child_sections) { Node new_child; - auto no_violation = Construct(art, keys, row_ids, new_child, child_section, has_constraint); + auto no_violation = ConstructInternal(art, keys, row_ids, new_child, child_section, has_constraint); Node::InsertChild(art, ref_node, child_section.key_byte, new_child); if (!no_violation) { return false; @@ -449,13 +473,13 @@ bool Construct(ART &art, vector &keys, row_t *row_ids, Node &node, KeySe bool ART::ConstructFromSorted(idx_t count, vector &keys, Vector &row_identifiers) { - // prepare the row_identifiers - row_identifiers.Flatten(count); - auto row_ids = FlatVector::GetData(row_identifiers); + UnifiedVectorFormat row_id_data; + row_identifiers.ToUnifiedFormat(count, row_id_data); + auto row_ids = UnifiedVectorFormat::GetData(row_id_data); auto key_section = KeySection(0, count - 1, 0, 0); auto has_constraint = IsUnique(); - if (!Construct(*this, keys, row_ids, tree, key_section, has_constraint)) { + if (!ConstructInternal(*this, keys, row_ids, tree, key_section, has_constraint)) { return false; } @@ -474,19 +498,18 @@ bool ART::ConstructFromSorted(idx_t count, vector &keys, Vector &row_ide //===--------------------------------------------------------------------===// // Insert / Verification / Constraint Checking //===--------------------------------------------------------------------===// -ErrorData ART::Insert(IndexLock &lock, DataChunk &input, Vector &row_ids) { +ErrorData ART::Insert(IndexLock &lock, DataChunk &input, Vector &row_identifiers) { - D_ASSERT(row_ids.GetType().InternalType() == ROW_TYPE); + D_ASSERT(row_identifiers.GetType().InternalType() == ROW_TYPE); D_ASSERT(logical_types[0] == input.data[0].GetType()); - // generate the keys for the given input ArenaAllocator arena_allocator(BufferAllocator::Get(db)); vector keys(input.size()); - GenerateKeys(arena_allocator, input, keys); + GenerateKeys<>(arena_allocator, input, keys); - // get the corresponding row IDs - row_ids.Flatten(input.size()); - auto row_identifiers = FlatVector::GetData(row_ids); + UnifiedVectorFormat row_id_data; + row_identifiers.ToUnifiedFormat(input.size(), row_id_data); + auto row_ids = UnifiedVectorFormat::GetData(row_id_data); // now insert the elements into the index idx_t failed_index = DConstants::INVALID_INDEX; @@ -495,7 +518,7 @@ ErrorData ART::Insert(IndexLock &lock, DataChunk &input, Vector &row_ids) { continue; } - row_t row_id = row_identifiers[i]; + auto row_id = row_ids[i]; if (!Insert(tree, keys[i], 0, row_id)) { // failed to insert because of constraint violation failed_index = i; @@ -509,7 +532,7 @@ ErrorData ART::Insert(IndexLock &lock, DataChunk &input, Vector &row_ids) { if (keys[i].Empty()) { continue; } - row_t row_id = row_identifiers[i]; + row_t row_id = row_ids[i]; Erase(tree, keys[i], 0, row_id); } } @@ -526,7 +549,7 @@ ErrorData ART::Insert(IndexLock &lock, DataChunk &input, Vector &row_ids) { } auto leaf = Lookup(tree, keys[i], 0); - D_ASSERT(Leaf::ContainsRowId(*this, *leaf, row_identifiers[i])); + D_ASSERT(Leaf::ContainsRowId(*this, *leaf, row_ids[i])); } #endif @@ -648,28 +671,25 @@ void ART::CommitDrop(IndexLock &index_lock) { tree.Clear(); } -void ART::Delete(IndexLock &state, DataChunk &input, Vector &row_ids) { +void ART::Delete(IndexLock &state, DataChunk &input, Vector &row_identifiers) { DataChunk expression; expression.Initialize(Allocator::DefaultAllocator(), logical_types); - - // first resolve the expressions ExecuteExpressions(input, expression); - // then generate the keys for the given input ArenaAllocator arena_allocator(BufferAllocator::Get(db)); vector keys(expression.size()); - GenerateKeys(arena_allocator, expression, keys); + GenerateKeys<>(arena_allocator, expression, keys); - // now erase the elements from the database - row_ids.Flatten(input.size()); - auto row_identifiers = FlatVector::GetData(row_ids); + UnifiedVectorFormat row_id_data; + row_identifiers.ToUnifiedFormat(input.size(), row_id_data); + auto row_ids = UnifiedVectorFormat::GetData(row_id_data); for (idx_t i = 0; i < input.size(); i++) { if (keys[i].Empty()) { continue; } - Erase(tree, keys[i], 0, row_identifiers[i]); + Erase(tree, keys[i], 0, row_ids[i]); } #ifdef DEBUG @@ -681,7 +701,7 @@ void ART::Delete(IndexLock &state, DataChunk &input, Vector &row_ids) { auto leaf = Lookup(tree, keys[i], 0); if (leaf) { - D_ASSERT(!Leaf::ContainsRowId(*this, *leaf, row_identifiers[i])); + D_ASSERT(!Leaf::ContainsRowId(*this, *leaf, row_ids[i])); } } #endif @@ -787,21 +807,6 @@ bool ART::SearchEqual(ARTKey &key, idx_t max_count, vector &result_ids) { return Leaf::GetRowIds(*this, *leaf, result_ids, max_count); } -void ART::SearchEqualJoinNoFetch(ARTKey &key, idx_t &result_size) { - - // we need to look for a leaf - auto leaf_node = Lookup(tree, key, 0); - if (!leaf_node) { - result_size = 0; - return; - } - - // we only perform index joins on PK/FK columns - D_ASSERT(leaf_node->GetType() == NType::LEAF_INLINED); - result_size = 1; - return; -} - //===--------------------------------------------------------------------===// // Lookup //===--------------------------------------------------------------------===// @@ -1040,10 +1045,9 @@ void ART::CheckConstraintsForChunk(DataChunk &input, ConflictManager &conflict_m expression_chunk.Initialize(Allocator::DefaultAllocator(), logical_types); ExecuteExpressions(input, expression_chunk); - // generate the keys for the given input ArenaAllocator arena_allocator(BufferAllocator::Get(db)); vector keys(expression_chunk.size()); - GenerateKeys(arena_allocator, expression_chunk, keys); + GenerateKeys<>(arena_allocator, expression_chunk, keys); idx_t found_conflict = DConstants::INVALID_INDEX; for (idx_t i = 0; found_conflict == DConstants::INVALID_INDEX && i < input.size(); i++) { diff --git a/src/execution/join_hashtable.cpp b/src/execution/join_hashtable.cpp index c1f273915e6..d43792bb779 100644 --- a/src/execution/join_hashtable.cpp +++ b/src/execution/join_hashtable.cpp @@ -4,23 +4,40 @@ #include "duckdb/common/row_operations/row_operations.hpp" #include "duckdb/common/types/column/column_data_collection_segment.hpp" #include "duckdb/common/vector_operations/vector_operations.hpp" +#include "duckdb/execution/ht_entry.hpp" #include "duckdb/main/client_context.hpp" #include "duckdb/storage/buffer_manager.hpp" namespace duckdb { - using ValidityBytes = JoinHashTable::ValidityBytes; using ScanStructure = JoinHashTable::ScanStructure; using ProbeSpill = JoinHashTable::ProbeSpill; using ProbeSpillLocalState = JoinHashTable::ProbeSpillLocalAppendState; +JoinHashTable::SharedState::SharedState() + : rhs_row_locations(LogicalType::POINTER), salt_match_sel(STANDARD_VECTOR_SIZE), + key_no_match_sel(STANDARD_VECTOR_SIZE) { +} + +JoinHashTable::ProbeState::ProbeState() + : SharedState(), salt_v(LogicalType::UBIGINT), ht_offsets_v(LogicalType::UBIGINT), + ht_offsets_dense_v(LogicalType::UBIGINT), non_empty_sel(STANDARD_VECTOR_SIZE) { +} + +JoinHashTable::InsertState::InsertState(const unique_ptr &data_collection, + const vector &equality_predicate_columns) + : SharedState(), remaining_sel(STANDARD_VECTOR_SIZE), key_match_sel(STANDARD_VECTOR_SIZE) { + data_collection->InitializeChunkState(chunk_state, equality_predicate_columns); +} + JoinHashTable::JoinHashTable(BufferManager &buffer_manager_p, const vector &conditions_p, vector btypes, JoinType type_p, const vector &output_columns_p) : buffer_manager(buffer_manager_p), conditions(conditions_p), build_types(std::move(btypes)), output_columns(output_columns_p), entry_size(0), tuple_size(0), vfound(Value::BOOLEAN(false)), join_type(type_p), finalized(false), has_null(false), radix_bits(INITIAL_RADIX_BITS), partition_start(0), partition_end(0) { - for (auto &condition : conditions) { + for (idx_t i = 0; i < conditions.size(); ++i) { + auto &condition = conditions[i]; D_ASSERT(condition.left->return_type == condition.right->return_type); auto type = condition.left->return_type; if (condition.comparison == ExpressionType::COMPARE_EQUAL || @@ -30,9 +47,15 @@ JoinHashTable::JoinHashTable(BufferManager &buffer_manager_p, const vector(new RowMatcher()); + row_matcher_probe_no_match_sel = unique_ptr(new RowMatcher()); + + row_matcher_probe->Initialize(false, layout, non_equality_predicates, non_equality_predicate_columns); + row_matcher_probe_no_match_sel->Initialize(true, layout, non_equality_predicates, + non_equality_predicate_columns); + + needs_chain_matcher = true; + } else { + needs_chain_matcher = false; + } + + chains_longer_than_one = false; + row_matcher_build.Initialize(true, layout, equality_predicates); const auto &offsets = layout.GetOffsets(); tuple_size = offsets[condition_types.size() + build_types.size()]; @@ -62,6 +101,9 @@ JoinHashTable::JoinHashTable(BufferManager &buffer_manager_p, const vector(buffer_manager, layout); sink_collection = make_uniq(buffer_manager, layout, radix_bits, layout.ColumnCount() - 1); + + dead_end = make_unsafe_uniq_array(layout.GetRowWidth()); + memset(dead_end.get(), 0, layout.GetRowWidth()); } JoinHashTable::~JoinHashTable() { @@ -86,32 +128,190 @@ void JoinHashTable::Merge(JoinHashTable &other) { sink_collection->Combine(*other.sink_collection); } -void JoinHashTable::ApplyBitmask(Vector &hashes, idx_t count) { - if (hashes.GetVectorType() == VectorType::CONSTANT_VECTOR) { - D_ASSERT(!ConstantVector::IsNull(hashes)); - auto indices = ConstantVector::GetData(hashes); - *indices = *indices & bitmask; +static void ApplyBitmaskAndGetSaltBuild(Vector &hashes_v, const idx_t &count, const idx_t &bitmask) { + + if (hashes_v.GetVectorType() == VectorType::CONSTANT_VECTOR) { + + D_ASSERT(!ConstantVector::IsNull(hashes_v)); + + auto indices = ConstantVector::GetData(hashes_v); + hash_t salt = ht_entry_t::ExtractSaltWithNulls(*indices); + idx_t offset = *indices & bitmask; + *indices = offset | salt; + hashes_v.Flatten(count); + } else { - hashes.Flatten(count); - auto indices = FlatVector::GetData(hashes); + hashes_v.Flatten(count); + auto hashes = FlatVector::GetData(hashes_v); + for (idx_t i = 0; i < count; i++) { - indices[i] &= bitmask; + idx_t salt = ht_entry_t::ExtractSaltWithNulls(hashes[i]); + idx_t offset = hashes[i] & bitmask; + hashes[i] = offset | salt; } } } -void JoinHashTable::ApplyBitmask(Vector &hashes, const SelectionVector &sel, idx_t count, Vector &pointers) { - UnifiedVectorFormat hdata; - hashes.ToUnifiedFormat(count, hdata); +// uses an AND operation to apply the modulo operation instead of an if condition that could be branch mispredicted +inline void IncrementAndWrap(idx_t &value, const uint64_t &capacity_mask) { + value += 1; + // leave the salt bits unchanged + value &= capacity_mask; +} + +//! Gets a pointer to the entry in the HT for each of the hashes_v using linear probing. Will update the key_match_sel +//! vector and the count argument to the number and position of the matches +template +static inline void GetRowPointersInternal(DataChunk &keys, TupleDataChunkState &key_state, + JoinHashTable::ProbeState &state, Vector &hashes_v, + const SelectionVector &sel, idx_t &count, JoinHashTable *ht, + ht_entry_t *entries, Vector &pointers_result_v, SelectionVector &match_sel) { + + UnifiedVectorFormat hashes_v_unified; + hashes_v.ToUnifiedFormat(count, hashes_v_unified); + + auto hashes = UnifiedVectorFormat::GetData(hashes_v_unified); + auto salts = FlatVector::GetData(state.salt_v); + + auto ht_offsets = FlatVector::GetData(state.ht_offsets_v); + auto ht_offsets_dense = FlatVector::GetData(state.ht_offsets_dense_v); - auto hash_data = UnifiedVectorFormat::GetData(hdata); - auto result_data = FlatVector::GetData(pointers); - auto main_ht = reinterpret_cast(hash_map.get()); + idx_t non_empty_count = 0; + + // first, filter out the empty rows and calculate the offset for (idx_t i = 0; i < count; i++) { - auto rindex = sel.get_index(i); - auto hindex = hdata.sel->get_index(rindex); - auto hash = hash_data[hindex]; - result_data[rindex] = main_ht + (hash & bitmask); + const auto row_index = sel.get_index(i); + auto uvf_index = hashes_v_unified.sel->get_index(row_index); + auto ht_offset = hashes[uvf_index] & ht->bitmask; + ht_offsets_dense[i] = ht_offset; + ht_offsets[row_index] = ht_offset; + } + + // have a dense loop to have as few instructions as possible while producing cache misses as this is the + // first location where we access the big entries array + for (idx_t i = 0; i < count; i++) { + idx_t ht_offset = ht_offsets_dense[i]; + auto &entry = entries[ht_offset]; + bool occupied = entry.IsOccupied(); + state.non_empty_sel.set_index(non_empty_count, i); + non_empty_count += occupied; + } + + for (idx_t i = 0; i < non_empty_count; i++) { + // transform the dense index to the actual index in the sel vector + idx_t dense_index = state.non_empty_sel.get_index(i); + const auto row_index = sel.get_index(dense_index); + state.non_empty_sel.set_index(i, row_index); + + if (USE_SALTS) { + auto uvf_index = hashes_v_unified.sel->get_index(row_index); + auto hash = hashes[uvf_index]; + hash_t row_salt = ht_entry_t::ExtractSalt(hash); + salts[row_index] = row_salt; + } + } + + auto pointers_result = FlatVector::GetData(pointers_result_v); + auto row_ptr_insert_to = FlatVector::GetData(state.rhs_row_locations); + + const SelectionVector *remaining_sel = &state.non_empty_sel; + idx_t remaining_count = non_empty_count; + + idx_t &match_count = count; + match_count = 0; + + while (remaining_count > 0) { + idx_t salt_match_count = 0; + idx_t key_no_match_count = 0; + + // for each entry, linear probing until + // a) an empty entry is found -> return nullptr (do nothing, as vector is zeroed) + // b) an entry is found where the salt matches -> need to compare the keys + for (idx_t i = 0; i < remaining_count; i++) { + const auto row_index = remaining_sel->get_index(i); + + idx_t &ht_offset = ht_offsets[row_index]; + bool occupied; + ht_entry_t entry; + + if (USE_SALTS) { + hash_t row_salt = salts[row_index]; + // increment the ht_offset of the entry as long as next entry is occupied and salt does not match + while (true) { + entry = entries[ht_offset]; + occupied = entry.IsOccupied(); + bool salt_match = entry.GetSalt() == row_salt; + + // condition for incrementing the ht_offset: occupied and row_salt does not match -> move to next + // entry + if (!occupied || salt_match) { + break; + } + + IncrementAndWrap(ht_offset, ht->bitmask); + } + } else { + entry = entries[ht_offset]; + occupied = entry.IsOccupied(); + } + + // the entries we need to process in the next iteration are the ones that are occupied and the row_salt + // does not match, the ones that are empty need no further processing + state.salt_match_sel.set_index(salt_match_count, row_index); + salt_match_count += occupied; + + // entry might be empty, so the pointer in the entry is nullptr, but this does not matter as the row + // will not be compared anyway as with an empty entry we are already done + row_ptr_insert_to[row_index] = entry.GetPointerOrNull(); + } + + if (salt_match_count != 0) { + // Perform row comparisons, after function call salt_match_sel will point to the keys that match + idx_t key_match_count = ht->row_matcher_build.Match(keys, key_state.vector_data, state.salt_match_sel, + salt_match_count, ht->layout, state.rhs_row_locations, + &state.key_no_match_sel, key_no_match_count); + + D_ASSERT(key_match_count + key_no_match_count == salt_match_count); + + // Set a pointer to the matching row + for (idx_t i = 0; i < key_match_count; i++) { + const auto row_index = state.salt_match_sel.get_index(i); + pointers_result[row_index] = row_ptr_insert_to[row_index]; + + match_sel.set_index(match_count, row_index); + match_count++; + } + + // Linear probing: each of the entries that do not match move to the next entry in the HT + for (idx_t i = 0; i < key_no_match_count; i++) { + const auto row_index = state.key_no_match_sel.get_index(i); + auto &ht_offset = ht_offsets[row_index]; + + IncrementAndWrap(ht_offset, ht->bitmask); + } + } + + remaining_sel = &state.key_no_match_sel; + remaining_count = key_no_match_count; + } +} + +inline bool JoinHashTable::UseSalt() const { + // only use salt for large hash tables and if there is only one equality condition as otherwise + // we potentially need to compare multiple keys + return this->capacity > USE_SALT_THRESHOLD && this->equality_predicate_columns.size() == 1; +} + +void JoinHashTable::GetRowPointers(DataChunk &keys, TupleDataChunkState &key_state, ProbeState &state, Vector &hashes_v, + const SelectionVector &sel, idx_t &count, Vector &pointers_result_v, + SelectionVector &match_sel) { + + if (UseSalt()) { + GetRowPointersInternal(keys, key_state, state, hashes_v, sel, count, this, entries, pointers_result_v, + match_sel); + } else { + GetRowPointersInternal(keys, key_state, state, hashes_v, sel, count, this, entries, pointers_result_v, + match_sel); } } @@ -243,65 +443,254 @@ idx_t JoinHashTable::PrepareKeys(DataChunk &keys, vector return added_count; } -template -static inline void InsertHashesLoop(atomic pointers[], const hash_t indices[], const idx_t count, - const data_ptr_t key_locations[], const idx_t pointer_offset) { - for (idx_t i = 0; i < count; i++) { - const auto index = indices[i]; - if (PARALLEL) { - data_ptr_t head; +//! If we consider to insert into an entry we expct to be empty, if it was filled in the meantime the insert will not +//! happen and we need to return the pointer to the to row with which the new entry would have collided. In any other +//! case we return a nullptr +template +static inline data_ptr_t InsertRowToEntry(atomic &entry, data_ptr_t row_ptr_to_insert, const hash_t salt, + const idx_t pointer_offset) { + + if (PARALLEL) { + // if we expect the entry to be empty, if the operation fails we need to cancel the whole operation as another + // key might have been inserted in the meantime that does not match the current key + if (EXPECT_EMPTY) { + + // add nullptr to the end of the list to mark the end + Store(nullptr, row_ptr_to_insert + pointer_offset); + + ht_entry_t new_empty_entry = ht_entry_t::GetDesiredEntry(row_ptr_to_insert, salt); + ht_entry_t expected_empty_entry = ht_entry_t::GetEmptyEntry(); + std::atomic_compare_exchange_weak(&entry, &expected_empty_entry, new_empty_entry); + + // if the expected empty entry actually was null, we can just return the pointer, and it will be a nullptr + // if the expected entry was filled in the meantime, we need to cancel the operation and will return the + // pointer to the next entry + return expected_empty_entry.GetPointerOrNull(); + } + + // if we expect the entry to be full, we know that even if the insert fails the keys still match so we can + // just keep trying until we succeed + else { + ht_entry_t expected_current_entry = entry.load(std::memory_order_relaxed); + ht_entry_t desired_new_entry = ht_entry_t::GetDesiredEntry(row_ptr_to_insert, salt); + D_ASSERT(expected_current_entry.IsOccupied()); + do { - head = pointers[index]; - Store(head, key_locations[i] + pointer_offset); - } while (!std::atomic_compare_exchange_weak(&pointers[index], &head, key_locations[i])); - } else { - // set prev in current key to the value (NOTE: this will be nullptr if there is none) - Store(pointers[index], key_locations[i] + pointer_offset); + data_ptr_t current_row_pointer = expected_current_entry.GetPointer(); + Store(current_row_pointer, row_ptr_to_insert + pointer_offset); + } while (!std::atomic_compare_exchange_weak(&entry, &expected_current_entry, desired_new_entry)); - // set pointer to current tuple - pointers[index] = key_locations[i]; + return nullptr; } } + // if we are not in parallel mode, we can just do the operation without any checks + else { + ht_entry_t current_entry = entry.load(std::memory_order_relaxed); + data_ptr_t current_row_pointer = current_entry.GetPointerOrNull(); + Store(current_row_pointer, row_ptr_to_insert + pointer_offset); + entry = ht_entry_t::GetDesiredEntry(row_ptr_to_insert, salt); + return nullptr; + } } +static inline void PerformKeyComparison(atomic entries[], JoinHashTable::InsertState &state, + JoinHashTable *ht, const unique_ptr &data_collection, + Vector &row_locations, const idx_t count, idx_t &key_match_count, + idx_t &key_no_match_count) { + // Get the data for the rows that need to be compared + DataChunk lhs_data; + data_collection->InitializeChunk(lhs_data, + ht->equality_predicate_columns); // makes sure DataChunk has the right format + lhs_data.SetCardinality(count); // and the right size + + // The target selection vector says where to write the results into the lhs_data, we just want to write + // sequentially as otherwise we trigger a bug in the Gather function + data_collection->Gather(row_locations, state.salt_match_sel, count, ht->equality_predicate_columns, lhs_data, + *FlatVector::IncrementalSelectionVector(), state.chunk_state.cached_cast_vectors); + + TupleDataCollection::ToUnifiedFormat(state.chunk_state, lhs_data); -void JoinHashTable::InsertHashes(Vector &hashes, idx_t count, data_ptr_t key_locations[], bool parallel) { - D_ASSERT(hashes.GetType().id() == LogicalType::HASH); + for (idx_t i = 0; i < count; i++) { + state.key_match_sel.set_index(i, i); + } + + // Perform row comparisons + key_match_count = + ht->row_matcher_build.Match(lhs_data, state.chunk_state.vector_data, state.key_match_sel, count, ht->layout, + state.rhs_row_locations, &state.key_no_match_sel, key_no_match_count); + + D_ASSERT(key_match_count + key_no_match_count == count); +} - // use bitmask to get position in array - ApplyBitmask(hashes, count); +template +static inline void InsertMatchesAndIncrementMisses(atomic entries[], JoinHashTable::InsertState &state, + JoinHashTable *ht, data_ptr_t *lhs_row_locations, + idx_t *ht_offsets_and_salts, const idx_t capacity_mask, + const idx_t key_match_count, const idx_t key_no_match_count) { + // Insert the rows that match + for (idx_t i = 0; i < key_match_count; i++) { + const auto need_compare_idx = state.key_match_sel.get_index(i); + const auto entry_index = state.salt_match_sel.get_index(need_compare_idx); + + idx_t ht_offset = ht_offsets_and_salts[entry_index] & ht_entry_t::POINTER_MASK; + auto &entry = entries[ht_offset]; + data_ptr_t row_ptr_to_insert = lhs_row_locations[entry_index]; + + auto salt = ht_offsets_and_salts[entry_index]; + InsertRowToEntry(entry, row_ptr_to_insert, salt, ht->pointer_offset); + + ht->chains_longer_than_one = true; + } - hashes.Flatten(count); - D_ASSERT(hashes.GetVectorType() == VectorType::FLAT_VECTOR); + // Linear probing: each of the entries that do not match move to the next entry in the HT + for (idx_t i = 0; i < key_no_match_count; i++) { - auto pointers = reinterpret_cast *>(hash_map.get()); - auto indices = FlatVector::GetData(hashes); + const auto need_compare_idx = state.key_no_match_sel.get_index(i); + const auto entry_index = state.salt_match_sel.get_index(need_compare_idx); + + idx_t &ht_offset_and_salt = ht_offsets_and_salts[entry_index]; + + IncrementAndWrap(ht_offset_and_salt, capacity_mask); + + state.remaining_sel.set_index(i, entry_index); + } +} + +template +static void InsertHashesLoop(atomic entries[], Vector row_locations, Vector &hashes_v, const idx_t &count, + JoinHashTable::InsertState &state, unique_ptr &data_collection, + JoinHashTable *ht) { + D_ASSERT(hashes_v.GetType().id() == LogicalType::HASH); + ApplyBitmaskAndGetSaltBuild(hashes_v, count, ht->bitmask); + + // the offset for each row to insert + idx_t *ht_offsets_and_salts = FlatVector::GetData(hashes_v); + // the row locations of the rows that are already in the hash table + data_ptr_t *rhs_row_locations = FlatVector::GetData(state.rhs_row_locations); + // the row locations of the rows that are to be inserted + data_ptr_t *lhs_row_locations = FlatVector::GetData(row_locations); + + const SelectionVector *remaining_sel = FlatVector::IncrementalSelectionVector(); + idx_t remaining_count = count; + + // use the ht bitmask to make the modulo operation faster but keep the salt bits intact + idx_t capacity_mask = ht->bitmask | ht_entry_t::SALT_MASK; + while (remaining_count > 0) { + idx_t salt_match_count = 0; + + // iterate over each entry to find out whether it belongs to an existing list or will start + // a new list + for (idx_t i = 0; i < remaining_count; i++) { + + const idx_t row_index = remaining_sel->get_index(i); + + idx_t &ht_offset_and_salt = ht_offsets_and_salts[row_index]; + const hash_t salt = ht_entry_t::ExtractSalt(ht_offset_and_salt); + + idx_t ht_offset; + ht_entry_t entry; + bool occupied, salt_match; + + // increment the ht_offset_and_salt of the entry as long as next entry is occupied and salt does not match + while (true) { + ht_offset = ht_offset_and_salt & ht_entry_t::POINTER_MASK; + atomic &atomic_entry = entries[ht_offset]; + entry = atomic_entry.load(std::memory_order_relaxed); + occupied = entry.IsOccupied(); + salt_match = entry.GetSalt() == salt; + + // condition for incrementing the ht_offset: occupied and row_salt does not match -> move to next entry + if (!occupied || salt_match) { + break; + } + + IncrementAndWrap(ht_offset_and_salt, capacity_mask); + } + + if (!occupied) { // insert into free + atomic &atomic_entry = entries[ht_offset]; + data_ptr_t row_ptr_to_insert = lhs_row_locations[row_index]; + data_ptr_t potential_collided_ptr = + InsertRowToEntry(atomic_entry, row_ptr_to_insert, salt, ht->pointer_offset); + + if (PARALLEL) { + // if the insertion was not successful, the entry was occupied in the meantime, so we have to + // compare the keys and insert the row to the next entry + if (potential_collided_ptr) { + // if the entry was occupied, we need to compare the keys and insert the row to the next entry + // we need to compare the keys and insert the row to the next entry + state.salt_match_sel.set_index(salt_match_count, row_index); + rhs_row_locations[salt_match_count] = potential_collided_ptr; + salt_match_count += 1; + } + } + + } else { // compare with full entry + state.salt_match_sel.set_index(salt_match_count, row_index); + rhs_row_locations[salt_match_count] = entry.GetPointer(); + salt_match_count += 1; + } + } + + // at this step, for all the rows to insert we stepped either until we found an empty entry or an entry with + // a matching salt, we now need to compare the keys for the ones that have a matching salt + + idx_t key_match_count = 0; + idx_t key_no_match_count = 0; + + if (salt_match_count != 0) { + + PerformKeyComparison(entries, state, ht, data_collection, row_locations, salt_match_count, key_match_count, + key_no_match_count); + + InsertMatchesAndIncrementMisses(entries, state, ht, lhs_row_locations, ht_offsets_and_salts, + capacity_mask, key_match_count, key_no_match_count); + } + + // update the overall selection vector to only point the entries that still need to be inserted + // as there was no match found for them yet + remaining_sel = &state.remaining_sel; + remaining_count = key_no_match_count; + } +} + +void JoinHashTable::InsertHashes(Vector &hashes_v, idx_t count, TupleDataChunkState &chunk_state, + InsertState &insert_state, bool parallel) { + auto atomic_entries = reinterpret_cast *>(this->entries); + auto row_locations = chunk_state.row_locations; if (parallel) { - InsertHashesLoop(pointers, indices, count, key_locations, pointer_offset); + InsertHashesLoop(atomic_entries, row_locations, hashes_v, count, insert_state, this->data_collection, + this); } else { - InsertHashesLoop(pointers, indices, count, key_locations, pointer_offset); + InsertHashesLoop(atomic_entries, row_locations, hashes_v, count, insert_state, this->data_collection, + this); } } void JoinHashTable::InitializePointerTable() { - idx_t capacity = PointerTableCapacity(Count()); + capacity = PointerTableCapacity(Count()); D_ASSERT(IsPowerOfTwo(capacity)); if (hash_map.get()) { // There is already a hash map - auto current_capacity = hash_map.GetSize() / sizeof(data_ptr_t); - if (capacity != current_capacity) { - // Different size, re-allocate + auto current_capacity = hash_map.GetSize() / sizeof(ht_entry_t); + if (capacity > current_capacity) { + // Need more space hash_map = buffer_manager.GetBufferAllocator().Allocate(capacity * sizeof(data_ptr_t)); + entries = reinterpret_cast(hash_map.get()); + } else { + // Just use the current hash map + capacity = current_capacity; } } else { // Allocate a hash map - hash_map = buffer_manager.GetBufferAllocator().Allocate(capacity * sizeof(data_ptr_t)); + hash_map = buffer_manager.GetBufferAllocator().Allocate(capacity * sizeof(ht_entry_t)); + entries = reinterpret_cast(hash_map.get()); } - D_ASSERT(hash_map.GetSize() == capacity * sizeof(data_ptr_t)); + D_ASSERT(hash_map.GetSize() == capacity * sizeof(ht_entry_t)); // initialize HT with all-zero entries - std::fill_n(reinterpret_cast(hash_map.get()), capacity, nullptr); + std::fill_n(entries, capacity, ht_entry_t::GetEmptyEntry()); bitmask = capacity - 1; } @@ -316,12 +705,16 @@ void JoinHashTable::Finalize(idx_t chunk_idx_from, idx_t chunk_idx_to, bool para TupleDataChunkIterator iterator(*data_collection, TupleDataPinProperties::KEEP_EVERYTHING_PINNED, chunk_idx_from, chunk_idx_to, false); const auto row_locations = iterator.GetRowLocations(); + + InsertState insert_state(this->data_collection, this->equality_predicate_columns); do { const auto count = iterator.GetCurrentChunkCount(); for (idx_t i = 0; i < count; i++) { hash_data[i] = Load(row_locations[i] + pointer_offset); } - InsertHashes(hashes, count, row_locations, parallel); + TupleDataChunkState &chunk_state = iterator.GetChunkState(); + + InsertHashes(hashes, count, chunk_state, insert_state, parallel); } while (iterator.Next()); } @@ -332,7 +725,6 @@ unique_ptr JoinHashTable::InitializeScanStructure(DataChunk &keys // set up the scan structure auto ss = make_uniq(*this, key_state); - if (join_type != JoinType::INNER) { ss->found_match = make_unsafe_uniq_array(STANDARD_VECTOR_SIZE); memset(ss->found_match.get(), 0, sizeof(bool) * STANDARD_VECTOR_SIZE); @@ -344,8 +736,8 @@ unique_ptr JoinHashTable::InitializeScanStructure(DataChunk &keys return ss; } -unique_ptr JoinHashTable::Probe(DataChunk &keys, TupleDataChunkState &key_state, - Vector *precomputed_hashes) { +unique_ptr JoinHashTable::Probe(DataChunk &keys, TupleDataChunkState &key_state, ProbeState &probe_state, + optional_ptr precomputed_hashes) { const SelectionVector *current_sel; auto ss = InitializeScanStructure(keys, key_state, current_sel); if (ss->count == 0) { @@ -353,24 +745,23 @@ unique_ptr JoinHashTable::Probe(DataChunk &keys, TupleDataChunkSt } if (precomputed_hashes) { - ApplyBitmask(*precomputed_hashes, *current_sel, ss->count, ss->pointers); + GetRowPointers(keys, key_state, probe_state, *precomputed_hashes, *current_sel, ss->count, ss->pointers, + ss->sel_vector); } else { - // hash all the keys Vector hashes(LogicalType::HASH); + // hash all the keys Hash(keys, *current_sel, ss->count, hashes); // now initialize the pointers of the scan structure based on the hashes - ApplyBitmask(hashes, *current_sel, ss->count, ss->pointers); + GetRowPointers(keys, key_state, probe_state, hashes, *current_sel, ss->count, ss->pointers, ss->sel_vector); } - // create the selection vector linking to only non-empty entries - ss->InitializeSelectionVector(current_sel); - return ss; } ScanStructure::ScanStructure(JoinHashTable &ht_p, TupleDataChunkState &key_state_p) - : key_state(key_state_p), pointers(LogicalType::POINTER), sel_vector(STANDARD_VECTOR_SIZE), ht(ht_p), + : key_state(key_state_p), pointers(LogicalType::POINTER), sel_vector(STANDARD_VECTOR_SIZE), + chain_match_sel_vector(STANDARD_VECTOR_SIZE), chain_no_match_sel_vector(STANDARD_VECTOR_SIZE), ht(ht_p), finished(false) { } @@ -381,8 +772,6 @@ void ScanStructure::Next(DataChunk &keys, DataChunk &left, DataChunk &result) { switch (ht.join_type) { case JoinType::INNER: case JoinType::RIGHT: - case JoinType::RIGHT_ANTI: - case JoinType::RIGHT_SEMI: NextInnerJoin(keys, left, result); break; case JoinType::SEMI: @@ -394,6 +783,10 @@ void ScanStructure::Next(DataChunk &keys, DataChunk &left, DataChunk &result) { case JoinType::ANTI: NextAntiJoin(keys, left, result); break; + case JoinType::RIGHT_ANTI: + case JoinType::RIGHT_SEMI: + NextRightSemiOrAntiJoin(keys, left, result); + break; case JoinType::OUTER: case JoinType::LEFT: NextLeftJoin(keys, left, result); @@ -406,7 +799,7 @@ void ScanStructure::Next(DataChunk &keys, DataChunk &left, DataChunk &result) { } } -bool ScanStructure::PointersExhausted() { +bool ScanStructure::PointersExhausted() const { // AdvancePointers creates a "new_count" for every pointer advanced during the // previous advance pointers call. If no pointers are advanced, new_count = 0. // count is then set ot new_count. @@ -414,20 +807,36 @@ bool ScanStructure::PointersExhausted() { } idx_t ScanStructure::ResolvePredicates(DataChunk &keys, SelectionVector &match_sel, SelectionVector *no_match_sel) { - // Start with the scan selection + + // Initialize the found_match array to the current sel_vector for (idx_t i = 0; i < this->count; ++i) { match_sel.set_index(i, this->sel_vector.get_index(i)); } - idx_t no_match_count = 0; - auto &matcher = no_match_sel ? ht.row_matcher_no_match_sel : ht.row_matcher; - return matcher.Match(keys, key_state.vector_data, match_sel, this->count, ht.layout, pointers, no_match_sel, - no_match_count); + // If there is a matcher for the probing side because of non-equality predicates, use it + if (ht.needs_chain_matcher) { + + idx_t no_match_count = 0; + + auto &matcher = no_match_sel ? ht.row_matcher_probe_no_match_sel : ht.row_matcher_probe; + + D_ASSERT(matcher); + + // we need to only use the vectors with the indices of the columns that are used in the probe phase, namely + // the non-equality columns + + return matcher->Match(keys, key_state.vector_data, match_sel, this->count, ht.layout, pointers, no_match_sel, + no_match_count, ht.non_equality_predicate_columns); + } else { + // no match sel is the opposite of match sel + return this->count; + } } idx_t ScanStructure::ScanInnerJoin(DataChunk &keys, SelectionVector &result_vector) { while (true) { - // resolve the predicates for this set of keys + + // resolve the equality_predicates for this set of keys idx_t result_count = ResolvePredicates(keys, result_vector, nullptr); // after doing all the comparisons set the found_match vector @@ -449,6 +858,12 @@ idx_t ScanStructure::ScanInnerJoin(DataChunk &keys, SelectionVector &result_vect } void ScanStructure::AdvancePointers(const SelectionVector &sel, idx_t sel_count) { + + if (!ht.chains_longer_than_one) { + this->count = 0; + return; + } + // now for all the pointers, we move on to the next set of pointers idx_t new_count = 0; auto ptrs = FlatVector::GetData(this->pointers); @@ -462,20 +877,6 @@ void ScanStructure::AdvancePointers(const SelectionVector &sel, idx_t sel_count) this->count = new_count; } -void ScanStructure::InitializeSelectionVector(const SelectionVector *¤t_sel) { - idx_t non_empty_count = 0; - auto ptrs = FlatVector::GetData(pointers); - auto cnt = count; - for (idx_t i = 0; i < cnt; i++) { - const auto idx = current_sel->get_index(i); - ptrs[idx] = Load(ptrs[idx]); - if (ptrs[idx]) { - sel_vector.set_index(non_empty_count++, idx); - } - } - count = non_empty_count; -} - void ScanStructure::AdvancePointers() { AdvancePointers(this->sel_vector, this->count); } @@ -499,17 +900,17 @@ void ScanStructure::NextInnerJoin(DataChunk &keys, DataChunk &left, DataChunk &r return; } - SelectionVector result_vector(STANDARD_VECTOR_SIZE); + idx_t result_count = ScanInnerJoin(keys, chain_match_sel_vector); - idx_t result_count = ScanInnerJoin(keys, result_vector); if (result_count > 0) { if (PropagatesBuildSide(ht.join_type)) { // full/right outer join: mark join matches as FOUND in the HT auto ptrs = FlatVector::GetData(pointers); for (idx_t i = 0; i < result_count; i++) { - auto idx = result_vector.get_index(i); - // NOTE: threadsan reports this as a data race because this can be set concurrently by separate threads - // Technically it is, but it does not matter, since the only value that can be written is "true" + auto idx = chain_match_sel_vector.get_index(i); + // NOTE: threadsan reports this as a data race because this can be set concurrently by separate + // threads Technically it is, but it does not matter, since the only value that can be written is + // "true" Store(true, ptrs[idx] + ht.tuple_size); } } @@ -518,14 +919,14 @@ void ScanStructure::NextInnerJoin(DataChunk &keys, DataChunk &left, DataChunk &r // matches were found // construct the result // on the LHS, we create a slice using the result vector - result.Slice(left, result_vector, result_count); + result.Slice(left, chain_match_sel_vector, result_count); // on the RHS, we need to fetch the data from the hash table for (idx_t i = 0; i < ht.output_columns.size(); i++) { auto &vector = result.data[left.ColumnCount() + i]; const auto output_col_idx = ht.output_columns[i]; D_ASSERT(vector.GetType() == ht.layout.GetTypes()[output_col_idx]); - GatherResult(vector, result_vector, result_count, output_col_idx); + GatherResult(vector, chain_match_sel_vector, result_count, output_col_idx); } } AdvancePointers(); @@ -538,18 +939,20 @@ void ScanStructure::ScanKeyMatches(DataChunk &keys) { // we handle the entire chunk in one call to Next(). // for every pointer, we keep chasing pointers and doing comparisons. // this results in a boolean array indicating whether or not the tuple has a match - SelectionVector match_sel(STANDARD_VECTOR_SIZE), no_match_sel(STANDARD_VECTOR_SIZE); + // Start with the scan selection + while (this->count > 0) { - // resolve the predicates for the current set of pointers - idx_t match_count = ResolvePredicates(keys, match_sel, &no_match_sel); + + // resolve the equality_predicates for the current set of pointers + idx_t match_count = ResolvePredicates(keys, chain_match_sel_vector, &chain_no_match_sel_vector); idx_t no_match_count = this->count - match_count; // mark each of the matches as found for (idx_t i = 0; i < match_count; i++) { - found_match[match_sel.get_index(i)] = true; + found_match[chain_match_sel_vector.get_index(i)] = true; } // continue searching for the ones where we did not find a match yet - AdvancePointers(no_match_sel, no_match_count); + AdvancePointers(chain_no_match_sel_vector, no_match_count); } } @@ -594,6 +997,41 @@ void ScanStructure::NextAntiJoin(DataChunk &keys, DataChunk &left, DataChunk &re finished = true; } +void ScanStructure::NextRightSemiOrAntiJoin(DataChunk &keys, DataChunk &left, DataChunk &result) { + const auto ptrs = FlatVector::GetData(pointers); + while (!PointersExhausted()) { + // resolve the equality_predicates for this set of keys + idx_t result_count = ResolvePredicates(keys, chain_match_sel_vector, nullptr); + + // for each match, fully follow the chain + for (idx_t i = 0; i < result_count; i++) { + const auto idx = chain_match_sel_vector.get_index(i); + auto &ptr = ptrs[idx]; + if (Load(ptr + ht.tuple_size)) { // Early out: chain has been fully marked as found before + ptr = ht.dead_end.get(); + continue; + } + + // Fully mark chain as found + while (true) { + // NOTE: threadsan reports this as a data race because this can be set concurrently by separate threads + // Technically it is, but it does not matter, since the only value that can be written is "true" + Store(true, ptr + ht.tuple_size); + auto next_ptr = Load(ptr + ht.pointer_offset); + if (!next_ptr) { + break; + } + ptr = next_ptr; + } + } + + // check the next set of pointers + AdvancePointers(); + } + + finished = true; +} + void ScanStructure::ConstructMarkJoinResult(DataChunk &join_keys, DataChunk &child, DataChunk &result) { // for the initial set of columns we just reference the left side result.SetCardinality(child); @@ -749,21 +1187,21 @@ void ScanStructure::NextSingleJoin(DataChunk &keys, DataChunk &input, DataChunk // (2) we return NULL for that data if there is no match idx_t result_count = 0; SelectionVector result_sel(STANDARD_VECTOR_SIZE); - SelectionVector match_sel(STANDARD_VECTOR_SIZE), no_match_sel(STANDARD_VECTOR_SIZE); + while (this->count > 0) { - // resolve the predicates for the current set of pointers - idx_t match_count = ResolvePredicates(keys, match_sel, &no_match_sel); + // resolve the equality_predicates for the current set of pointers + idx_t match_count = ResolvePredicates(keys, chain_match_sel_vector, &chain_no_match_sel_vector); idx_t no_match_count = this->count - match_count; // mark each of the matches as found for (idx_t i = 0; i < match_count; i++) { // found a match for this index - auto index = match_sel.get_index(i); + auto index = chain_match_sel_vector.get_index(i); found_match[index] = true; result_sel.set_index(result_count++, index); } // continue searching for the ones where we did not find a match yet - AdvancePointers(no_match_sel, no_match_count); + AdvancePointers(chain_no_match_sel_vector, no_match_count); } // reference the columns of the left side from the result D_ASSERT(input.ColumnCount() > 0); @@ -1020,8 +1458,8 @@ static void CreateSpillChunk(DataChunk &spill_chunk, DataChunk &keys, DataChunk } unique_ptr JoinHashTable::ProbeAndSpill(DataChunk &keys, TupleDataChunkState &key_state, - DataChunk &payload, ProbeSpill &probe_spill, - ProbeSpillLocalAppendState &spill_state, + ProbeState &probe_state, DataChunk &payload, + ProbeSpill &probe_spill, ProbeSpillLocalAppendState &spill_state, DataChunk &spill_chunk) { // hash all the keys Vector hashes(LogicalType::HASH); @@ -1055,10 +1493,7 @@ unique_ptr JoinHashTable::ProbeAndSpill(DataChunk &keys, TupleDat } // now initialize the pointers of the scan structure based on the hashes - ApplyBitmask(hashes, *current_sel, ss->count, ss->pointers); - - // create the selection vector linking to only non-empty entries - ss->InitializeSelectionVector(current_sel); + GetRowPointers(keys, key_state, probe_state, hashes, *current_sel, ss->count, ss->pointers, ss->sel_vector); return ss; } diff --git a/src/execution/operator/aggregate/physical_streaming_window.cpp b/src/execution/operator/aggregate/physical_streaming_window.cpp index aad0c0b3034..4473917873b 100644 --- a/src/execution/operator/aggregate/physical_streaming_window.cpp +++ b/src/execution/operator/aggregate/physical_streaming_window.cpp @@ -1,5 +1,6 @@ #include "duckdb/execution/operator/aggregate/physical_streaming_window.hpp" +#include "duckdb/execution/aggregate_hashtable.hpp" #include "duckdb/execution/expression_executor.hpp" #include "duckdb/function/aggregate_function.hpp" #include "duckdb/parallel/thread_context.hpp" @@ -18,9 +19,7 @@ bool PhysicalStreamingWindow::IsStreamingFunction(unique_ptr &expr) // TODO: add more expression types here? case ExpressionType::WINDOW_AGGREGATE: // We can stream aggregates if they are "running totals" - // TODO: Support DISTINCT - return wexpr.start == WindowBoundary::UNBOUNDED_PRECEDING && wexpr.end == WindowBoundary::CURRENT_ROW_ROWS && - !wexpr.distinct; + return wexpr.start == WindowBoundary::UNBOUNDED_PRECEDING && wexpr.end == WindowBoundary::CURRENT_ROW_ROWS; case ExpressionType::WINDOW_FIRST_VALUE: case ExpressionType::WINDOW_PERCENT_RANK: case ExpressionType::WINDOW_RANK: @@ -49,8 +48,9 @@ class StreamingWindowGlobalState : public GlobalOperatorState { class StreamingWindowState : public OperatorState { public: struct AggregateState { - explicit AggregateState(BoundWindowExpression &wexpr, Allocator &allocator) - : arena_allocator(Allocator::DefaultAllocator()), statev(LogicalType::POINTER, data_ptr_cast(&state_ptr)) { + AggregateState(ClientContext &client, BoundWindowExpression &wexpr, Allocator &allocator) + : arena_allocator(Allocator::DefaultAllocator()), statev(LogicalType::POINTER, data_ptr_cast(&state_ptr)), + hashes(LogicalType::HASH), addresses(LogicalType::POINTER) { D_ASSERT(wexpr.GetExpressionType() == ExpressionType::WINDOW_AGGREGATE); auto &aggregate = *wexpr.aggregate; bind_data = wexpr.bind_info.get(); @@ -68,6 +68,11 @@ class StreamingWindowState : public OperatorState { if (wexpr.filter_expr) { filter_sel.Initialize(); } + if (wexpr.distinct) { + distinct = make_uniq(client, allocator, arg_types); + distinct_args.Initialize(allocator, arg_types); + distinct_sel.Initialize(); + } } ~AggregateState() { @@ -100,6 +105,17 @@ class StreamingWindowState : public OperatorState { DataChunk arg_chunk; //! Argument cursor (a one element slice of arg_chunk) DataChunk arg_cursor; + + //! Hash table for accumulating the distinct values + unique_ptr distinct; + //! Filtered arguments for checking distinctness + DataChunk distinct_args; + //! Reusable hash vector + Vector hashes; + //! Rows that produced new distinct values + SelectionVector distinct_sel; + //! Pointers to groups in the hash table. + Vector addresses; }; explicit StreamingWindowState(ClientContext &client) : initialized(false), allocator(Allocator::Get(client)) { @@ -117,7 +133,7 @@ class StreamingWindowState : public OperatorState { auto &wexpr = expr.Cast(); switch (expr.GetExpressionType()) { case ExpressionType::WINDOW_AGGREGATE: - aggregate_states[expr_idx] = make_uniq(wexpr, allocator); + aggregate_states[expr_idx] = make_uniq(context, wexpr, allocator); break; case ExpressionType::WINDOW_FIRST_VALUE: { // Just execute the expression once @@ -191,10 +207,11 @@ OperatorResultType PhysicalStreamingWindow::Execute(ExecutionContext &context, D // Compute the FILTER mask (if any) ValidityMask filter_mask; + auto filtered = count; + auto &filter_sel = aggr_state.filter_sel; if (wexpr.filter_expr) { - auto &filter_sel = aggr_state.filter_sel; ExpressionExecutor filter_executor(context.client, *wexpr.filter_expr); - const auto filtered = filter_executor.SelectExpression(input, filter_sel); + filtered = filter_executor.SelectExpression(input, filter_sel); if (filtered < count) { filter_mask.Initialize(count); filter_mask.SetAllInvalid(count); @@ -223,9 +240,41 @@ OperatorResultType PhysicalStreamingWindow::Execute(ExecutionContext &context, D } auto &arg_chunk = aggr_state.arg_chunk; executor.Execute(input, arg_chunk); + arg_chunk.Flatten(); + + // Update the distinct hash table + ValidityMask distinct_mask; + if (aggr_state.distinct) { + auto &distinct_args = aggr_state.distinct_args; + distinct_args.Reference(arg_chunk); + if (wexpr.filter_expr) { + distinct_args.Slice(filter_sel, filtered); + } + idx_t distinct = 0; + auto &distinct_sel = aggr_state.distinct_sel; + if (filtered) { + // FindOrCreateGroups assumes non-empty input + auto &hashes = aggr_state.hashes; + distinct_args.Hash(hashes); + + auto &addresses = aggr_state.addresses; + distinct = aggr_state.distinct->FindOrCreateGroups(distinct_args, hashes, addresses, distinct_sel); + } + + // Translate the distinct selection from filtered row numbers + // back to input row numbers. We need to produce output for all input rows, + // so we filter out + if (distinct < filtered) { + distinct_mask.Initialize(count); + distinct_mask.SetAllInvalid(count); + for (idx_t d = 0; d < distinct; ++d) { + const auto f = distinct_sel.get_index(d); + distinct_mask.SetValid(filter_sel.get_index(f)); + } + } + } // Iterate through them using a single SV - arg_chunk.Flatten(); sel_t s = 0; SelectionVector sel(&s); auto &arg_cursor = aggr_state.arg_cursor; @@ -249,7 +298,7 @@ OperatorResultType PhysicalStreamingWindow::Execute(ExecutionContext &context, D for (const auto struct_idx : structs) { arg_cursor.data[struct_idx].Slice(arg_chunk.data[struct_idx], sel, 1); } - if (filter_mask.RowIsValid(i)) { + if (filter_mask.RowIsValid(i) && distinct_mask.RowIsValid(i)) { aggregate.update(arg_cursor.data.data(), aggr_input_data, arg_cursor.ColumnCount(), statev, 1); } aggregate.finalize(statev, aggr_input_data, result, 1, i); diff --git a/src/execution/operator/csv_scanner/buffer_manager/csv_buffer_manager.cpp b/src/execution/operator/csv_scanner/buffer_manager/csv_buffer_manager.cpp index 948e91cf937..c8a7d167678 100644 --- a/src/execution/operator/csv_scanner/buffer_manager/csv_buffer_manager.cpp +++ b/src/execution/operator/csv_scanner/buffer_manager/csv_buffer_manager.cpp @@ -4,8 +4,9 @@ namespace duckdb { CSVBufferManager::CSVBufferManager(ClientContext &context_p, const CSVReaderOptions &options, const string &file_path_p, - const idx_t file_idx_p) - : context(context_p), file_idx(file_idx_p), file_path(file_path_p), buffer_size(CSVBuffer::CSV_BUFFER_SIZE) { + const idx_t file_idx_p, bool per_file_single_threaded_p) + : context(context_p), per_file_single_threaded(per_file_single_threaded_p), file_idx(file_idx_p), + file_path(file_path_p), buffer_size(CSVBuffer::CSV_BUFFER_SIZE) { D_ASSERT(!file_path.empty()); file_handle = ReadCSV::OpenCSV(file_path, options.compression, context); is_pipe = file_handle->IsPipe(); @@ -71,7 +72,7 @@ shared_ptr CSVBufferManager::GetBuffer(const idx_t pos) { done = true; } } - if (pos != 0 && (sniffing || file_handle->CanSeek())) { + if (pos != 0 && (sniffing || file_handle->CanSeek() || per_file_single_threaded)) { // We don't need to unpin the buffers here if we are not sniffing since we // control it per-thread on the scan if (cached_buffers[pos - 1]) { diff --git a/src/execution/operator/csv_scanner/scanner/base_scanner.cpp b/src/execution/operator/csv_scanner/scanner/base_scanner.cpp index f789946a92e..0a6205484a8 100644 --- a/src/execution/operator/csv_scanner/scanner/base_scanner.cpp +++ b/src/execution/operator/csv_scanner/scanner/base_scanner.cpp @@ -13,7 +13,7 @@ BaseScanner::BaseScanner(shared_ptr buffer_manager_p, shared_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)) { + state_machine(std::move(state_machine_p)), buffer_manager(std::move(buffer_manager_p)), iterator(iterator_p) { D_ASSERT(buffer_manager); D_ASSERT(state_machine); // Initialize current buffer handle @@ -41,19 +41,15 @@ bool BaseScanner::FinishedFile() { return iterator.pos.buffer_pos + 1 == cur_buffer_handle->actual_size; } -void BaseScanner::SkipCSVRows(idx_t rows_to_skip) { +CSVIterator BaseScanner::SkipCSVRows(shared_ptr buffer_manager, + const shared_ptr &state_machine, idx_t rows_to_skip) { if (rows_to_skip == 0) { - return; + return {}; } - SkipScanner row_skipper(buffer_manager, state_machine, error_handler, rows_to_skip); + auto error_handler = make_shared_ptr(); + SkipScanner row_skipper(std::move(buffer_manager), state_machine, error_handler, rows_to_skip); row_skipper.ParseChunk(); - iterator.pos.buffer_pos = row_skipper.GetIteratorPosition(); - if (row_skipper.state_machine->options.dialect_options.state_machine_options.new_line == - NewLineIdentifier::CARRY_ON && - row_skipper.states.states[1] == CSVState::CARRIAGE_RETURN) { - iterator.pos.buffer_pos++; - } - lines_read += row_skipper.GetLinesRead(); + return row_skipper.GetIterator(); } CSVIterator &BaseScanner::GetIterator() { diff --git a/src/execution/operator/csv_scanner/scanner/column_count_scanner.cpp b/src/execution/operator/csv_scanner/scanner/column_count_scanner.cpp index 70542ef4b47..48898cecbac 100644 --- a/src/execution/operator/csv_scanner/scanner/column_count_scanner.cpp +++ b/src/execution/operator/csv_scanner/scanner/column_count_scanner.cpp @@ -41,17 +41,19 @@ void ColumnCountResult::QuotedNewLine(ColumnCountResult &result) { // nop } -ColumnCountScanner::ColumnCountScanner(shared_ptr buffer_manager, +ColumnCountScanner::ColumnCountScanner(shared_ptr buffer_manager_p, const shared_ptr &state_machine, - shared_ptr error_handler) - : BaseScanner(std::move(buffer_manager), state_machine, std::move(error_handler)), result(states, *state_machine), - column_count(1) { - sniffing = true; + shared_ptr error_handler, CSVIterator iterator) + : BaseScanner(std::move(buffer_manager_p), state_machine, std::move(error_handler), true, nullptr, iterator), + result(states, *state_machine), column_count(1) { } unique_ptr ColumnCountScanner::UpgradeToStringValueScanner() { - auto scanner = make_uniq(0U, buffer_manager, state_machine, error_handler, nullptr, true); - return scanner; + auto iterator = SkipCSVRows(buffer_manager, state_machine, state_machine->dialect_options.skip_rows.GetValue()); + if (iterator.done) { + return make_uniq(0U, buffer_manager, state_machine, error_handler, nullptr, true); + } + return make_uniq(0U, buffer_manager, state_machine, error_handler, nullptr, true, iterator); } ColumnCountResult &ColumnCountScanner::ParseChunk() { diff --git a/src/execution/operator/csv_scanner/scanner/scanner_boundary.cpp b/src/execution/operator/csv_scanner/scanner/scanner_boundary.cpp index f1a93b7084a..4ddd938bbb7 100644 --- a/src/execution/operator/csv_scanner/scanner/scanner_boundary.cpp +++ b/src/execution/operator/csv_scanner/scanner/scanner_boundary.cpp @@ -2,28 +2,15 @@ namespace duckdb { -CSVPosition::CSVPosition(idx_t file_idx_p, idx_t buffer_idx_p, idx_t buffer_pos_p) - : file_idx(file_idx_p), buffer_idx(buffer_idx_p), buffer_pos(buffer_pos_p) { +CSVPosition::CSVPosition(idx_t buffer_idx_p, idx_t buffer_pos_p) : buffer_idx(buffer_idx_p), buffer_pos(buffer_pos_p) { } CSVPosition::CSVPosition() { } -CSVBoundary::CSVBoundary(idx_t file_idx_p, idx_t buffer_idx_p, idx_t buffer_pos_p, idx_t boundary_idx_p, - idx_t end_pos_p) - : file_idx(file_idx_p), buffer_idx(buffer_idx_p), buffer_pos(buffer_pos_p), boundary_idx(boundary_idx_p), - end_pos(end_pos_p) { +CSVBoundary::CSVBoundary(idx_t buffer_idx_p, idx_t buffer_pos_p, idx_t boundary_idx_p, idx_t end_pos_p) + : buffer_idx(buffer_idx_p), buffer_pos(buffer_pos_p), boundary_idx(boundary_idx_p), end_pos(end_pos_p) { } -CSVBoundary::CSVBoundary() - : file_idx(0), buffer_idx(0), buffer_pos(0), boundary_idx(0), end_pos(NumericLimits::Maximum()) { -} -CSVIterator::CSVIterator(idx_t file_idx, idx_t buffer_idx, idx_t buffer_pos, idx_t boundary_idx, idx_t buffer_size) - : pos(file_idx, buffer_idx, buffer_pos), is_set(true) { - // The end of our boundary will be the buffer size itself it that's smaller than where we want to go - if (buffer_size < buffer_pos + BYTES_PER_THREAD) { - boundary = {file_idx, buffer_idx, buffer_pos, boundary_idx, buffer_size}; - } else { - boundary = {file_idx, buffer_idx, buffer_pos, boundary_idx, buffer_pos + BYTES_PER_THREAD}; - } +CSVBoundary::CSVBoundary() : buffer_idx(0), buffer_pos(0), boundary_idx(0), end_pos(NumericLimits::Maximum()) { } CSVIterator::CSVIterator() : is_set(false) { @@ -32,7 +19,6 @@ CSVIterator::CSVIterator() : is_set(false) { void CSVBoundary::Print() { #ifndef DUCKDB_DISABLE_PRINT std::cout << "---Boundary: " << boundary_idx << " ---" << '\n'; - std::cout << "File Index:: " << file_idx << '\n'; std::cout << "Buffer Index: " << buffer_idx << '\n'; std::cout << "Buffer Pos: " << buffer_pos << '\n'; std::cout << "End Pos: " << end_pos << '\n'; @@ -51,6 +37,8 @@ bool CSVIterator::Next(CSVBufferManager &buffer_manager) { if (!is_set) { return false; } + // If we are calling next this is not the first one anymore + first_one = false; boundary.boundary_idx++; // This is our start buffer auto buffer = buffer_manager.GetBuffer(boundary.buffer_idx); @@ -84,10 +72,6 @@ idx_t CSVIterator::GetEndPos() const { return boundary.end_pos; } -idx_t CSVIterator::GetFileIdx() const { - return pos.file_idx; -} - idx_t CSVIterator::GetBufferIdx() const { return pos.buffer_idx; } @@ -97,11 +81,27 @@ idx_t CSVIterator::GetBoundaryIdx() const { } void CSVIterator::SetCurrentPositionToBoundary() { - pos.file_idx = boundary.file_idx; pos.buffer_idx = boundary.buffer_idx; pos.buffer_pos = boundary.buffer_pos; } +void CSVIterator::SetCurrentBoundaryToPosition(bool single_threaded) { + if (single_threaded) { + is_set = false; + return; + } + boundary.buffer_idx = pos.buffer_idx; + if (pos.buffer_pos == 0) { + boundary.end_pos = CSVIterator::BYTES_PER_THREAD; + } else { + boundary.end_pos = ((pos.buffer_pos + CSVIterator::BYTES_PER_THREAD - 1) / CSVIterator::BYTES_PER_THREAD) * + CSVIterator::BYTES_PER_THREAD; + } + + boundary.buffer_pos = boundary.end_pos - CSVIterator::BYTES_PER_THREAD; + is_set = true; +} + void CSVIterator::SetStart(idx_t start) { boundary.buffer_pos = start; } diff --git a/src/execution/operator/csv_scanner/scanner/skip_scanner.cpp b/src/execution/operator/csv_scanner/scanner/skip_scanner.cpp index 486c26b9f32..a1c78768128 100644 --- a/src/execution/operator/csv_scanner/scanner/skip_scanner.cpp +++ b/src/execution/operator/csv_scanner/scanner/skip_scanner.cpp @@ -38,6 +38,7 @@ bool SkipResult::EmptyLine(SkipResult &result, const idx_t buffer_pos) { } return false; } + SkipScanner::SkipScanner(shared_ptr buffer_manager, const shared_ptr &state_machine, shared_ptr error_handler, idx_t rows_to_skip) : BaseScanner(std::move(buffer_manager), state_machine, std::move(error_handler)), @@ -58,6 +59,20 @@ void SkipScanner::Initialize() { } void SkipScanner::FinalizeChunkProcess() { - // nop + // We continue skipping until we skipped enough rows, or we have nothing else to read. + while (!FinishedFile() && result.row_count < result.rows_to_skip) { + cur_buffer_handle = buffer_manager->GetBuffer(++iterator.pos.buffer_idx); + if (cur_buffer_handle) { + iterator.pos.buffer_pos = 0; + buffer_handle_ptr = cur_buffer_handle->Ptr(); + Process(result); + } + } + // Skip Carriage Return + if (state_machine->options.dialect_options.state_machine_options.new_line == NewLineIdentifier::CARRY_ON && + states.states[1] == CSVState::CARRIAGE_RETURN) { + iterator.pos.buffer_pos++; + } + iterator.done = FinishedFile(); } } // namespace duckdb diff --git a/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp b/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp index d9363074bfc..f7453f796f9 100644 --- a/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp +++ b/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp @@ -107,6 +107,14 @@ StringValueResult::StringValueResult(CSVStates &states, CSVStateMachine &state_m date_format = state_machine.options.dialect_options.date_format.at(LogicalTypeId::DATE).GetValue(); timestamp_format = state_machine.options.dialect_options.date_format.at(LogicalTypeId::TIMESTAMP).GetValue(); decimal_separator = state_machine.options.decimal_separator[0]; + + if (iterator.first_one) { + lines_read += + state_machine.dialect_options.skip_rows.GetValue() + state_machine.dialect_options.header.GetValue(); + if (lines_read == 0) { + SkipBOM(); + } + } } StringValueResult::~StringValueResult() { @@ -782,21 +790,24 @@ StringValueScanner::StringValueScanner(idx_t scanner_idx_p, const shared_ptr &buffer_manager, const shared_ptr &state_machine, - const shared_ptr &error_handler) - : BaseScanner(buffer_manager, state_machine, error_handler, false, nullptr, {}), scanner_idx(0), + const shared_ptr &error_handler, CSVIterator boundary) + : BaseScanner(buffer_manager, state_machine, error_handler, false, nullptr, boundary), scanner_idx(0), result(states, *state_machine, cur_buffer_handle, Allocator::DefaultAllocator(), false, iterator.pos.buffer_pos, *error_handler, iterator, buffer_manager->context.client_data->debug_set_max_line_length, csv_file_scan, lines_read, sniffing) { } unique_ptr StringValueScanner::GetCSVScanner(ClientContext &context, CSVReaderOptions &options) { + // Its possible we might have to do some skipping first auto state_machine = make_shared_ptr(options, options.dialect_options.state_machine_options, CSVStateMachineCache::Get(context)); state_machine->dialect_options.num_cols = options.dialect_options.num_cols; state_machine->dialect_options.header = options.dialect_options.header; auto buffer_manager = make_shared_ptr(context, options, options.file_path, 0); - auto scanner = make_uniq(buffer_manager, state_machine, make_shared_ptr()); + idx_t rows_to_skip = state_machine->options.GetSkipRows() + state_machine->options.GetHeader(); + auto it = BaseScanner::SkipCSVRows(buffer_manager, state_machine, rows_to_skip); + auto scanner = make_uniq(buffer_manager, state_machine, make_shared_ptr(), it); scanner->csv_file_scan = make_shared_ptr(context, options.file_path, options); scanner->csv_file_scan->InitializeProjection(); return scanner; @@ -940,7 +951,6 @@ void StringValueScanner::Flush(DataChunk &insert_chunk) { void StringValueScanner::Initialize() { states.Initialize(); - if (result.result_size != 1 && !(sniffing && state_machine->options.null_padding && !state_machine->options.dialect_options.skip_rows.IsSetByUser())) { SetStart(); @@ -1224,9 +1234,9 @@ bool StringValueScanner::MoveToNextBuffer() { return false; } -void StringValueScanner::SkipBOM() { - if (cur_buffer_handle->actual_size >= 3 && result.buffer_ptr[0] == '\xEF' && result.buffer_ptr[1] == '\xBB' && - result.buffer_ptr[2] == '\xBF') { +void StringValueResult::SkipBOM() { + if (buffer_size >= 3 && buffer_ptr[0] == '\xEF' && buffer_ptr[1] == '\xBB' && buffer_ptr[2] == '\xBF' && + iterator.pos.buffer_pos == 0) { iterator.pos.buffer_pos = 3; } } @@ -1286,13 +1296,7 @@ bool StringValueScanner::CanDirectlyCast(const LogicalType &type) { } void StringValueScanner::SetStart() { - if (iterator.pos.buffer_idx == 0 && iterator.pos.buffer_pos == 0) { - // This means this is the very first buffer - // This CSV is not from auto-detect, so we don't know where exactly it starts - // Hence we potentially have to skip empty lines and headers. - SkipBOM(); - SkipCSVRows(state_machine->dialect_options.skip_rows.GetValue() + - state_machine->dialect_options.header.GetValue()); + if (iterator.first_one) { if (result.store_line_size) { result.error_handler.NewMaxLineSize(iterator.pos.buffer_pos); } diff --git a/src/execution/operator/csv_scanner/sniffer/dialect_detection.cpp b/src/execution/operator/csv_scanner/sniffer/dialect_detection.cpp index b167cbed96b..48682a798df 100644 --- a/src/execution/operator/csv_scanner/sniffer/dialect_detection.cpp +++ b/src/execution/operator/csv_scanner/sniffer/dialect_detection.cpp @@ -68,6 +68,8 @@ void CSVSniffer::GenerateStateMachineSearchSpace(vector(options, state_machine_options, state_machine_cache); + make_shared_ptr(options, state_machine_options, state_machine_cache); + if (options.dialect_options.skip_rows.IsSetByUser()) { + if (!iterator_set) { + first_iterator = BaseScanner::SkipCSVRows(buffer_manager, sniffing_state_machine, + options.dialect_options.skip_rows.GetValue()); + iterator_set = true; + } + column_count_scanners.emplace_back( + make_uniq(buffer_manager, std::move(sniffing_state_machine), + detection_error_handler, first_iterator)); + continue; + } column_count_scanners.emplace_back(make_uniq( buffer_manager, std::move(sniffing_state_machine), detection_error_handler)); } @@ -319,24 +332,6 @@ NewLineIdentifier CSVSniffer::DetectNewLineDelimiter(CSVBufferManager &buffer_ma return NewLineIdentifier::SINGLE; } -void CSVSniffer::SkipLines(vector> &csv_state_machines) { - if (csv_state_machines.empty()) { - return; - } - auto &first_scanner = *csv_state_machines[0]; - // We figure out the iterator position for the first scanner - if (options.dialect_options.skip_rows.IsSetByUser()) { - first_scanner.SkipCSVRows(options.dialect_options.skip_rows.GetValue()); - } - // The iterator position is the same regardless of the scanner configuration, hence we apply the same iterator - // To the remaining scanners - const auto first_iterator = first_scanner.GetIterator(); - for (idx_t i = 1; i < csv_state_machines.size(); i++) { - auto &cur_scanner = *csv_state_machines[i]; - cur_scanner.SetIterator(first_iterator); - } -} - // Dialect Detection consists of five steps: // 1. Generate a search space of all possible dialects // 2. Generate a state machine for each dialect @@ -370,7 +365,6 @@ void CSVSniffer::DetectDialect() { // Step 2: Generate state machines GenerateStateMachineSearchSpace(csv_state_machines, delim_candidates, quoterule_candidates, quote_candidates_map, escape_candidates_map); - SkipLines(csv_state_machines); // Step 3: Analyze all candidates on the first chunk for (auto &state_machine : csv_state_machines) { AnalyzeDialectCandidate(std::move(state_machine), rows_read, best_consistent_rows, prev_padding_count); diff --git a/src/execution/operator/csv_scanner/sniffer/type_detection.cpp b/src/execution/operator/csv_scanner/sniffer/type_detection.cpp index 807449bab2d..8cb87dcbdd1 100644 --- a/src/execution/operator/csv_scanner/sniffer/type_detection.cpp +++ b/src/execution/operator/csv_scanner/sniffer/type_detection.cpp @@ -336,7 +336,6 @@ void CSVSniffer::DetectTypes() { // Reset candidate for parsing auto candidate = candidate_cc->UpgradeToStringValueScanner(); - // Parse chunk and read csv with info candidate auto &data_chunk = candidate->ParseChunk().ToChunk(); idx_t row_idx = 0; @@ -365,7 +364,7 @@ void CSVSniffer::DetectTypes() { // try cast from string to sql_type while (col_type_candidates.size() > 1) { const auto &sql_type = col_type_candidates.back(); - // try formatting for date types if the user did not specify one and it starts with numeric + // try formatting for date types if the user did not specify one, and it starts with numeric // values. string separator; // If Value is not Null, Has a numeric date format, and the current investigated candidate is diff --git a/src/execution/operator/csv_scanner/table_function/csv_file_scanner.cpp b/src/execution/operator/csv_scanner/table_function/csv_file_scanner.cpp index c022704108e..3bdb8e925e9 100644 --- a/src/execution/operator/csv_scanner/table_function/csv_file_scanner.cpp +++ b/src/execution/operator/csv_scanner/table_function/csv_file_scanner.cpp @@ -1,6 +1,8 @@ #include "duckdb/execution/operator/csv_scanner/csv_file_scanner.hpp" -#include "duckdb/function/table/read_csv.hpp" + #include "duckdb/execution/operator/csv_scanner/csv_sniffer.hpp" +#include "duckdb/execution/operator/csv_scanner/skip_scanner.hpp" +#include "duckdb/function/table/read_csv.hpp" namespace duckdb { @@ -39,11 +41,23 @@ CSVFileScan::CSVFileScan(ClientContext &context, shared_ptr bu bind_data.return_names, column_ids, nullptr, file_path, context, nullptr); InitializeFileNamesTypes(); + SetStart(); +} + +void CSVFileScan::SetStart() { + idx_t rows_to_skip = options.GetSkipRows() + state_machine->dialect_options.header.GetValue(); + if (rows_to_skip == 0) { + start_iterator.first_one = true; + return; + } + SkipScanner skip_scanner(buffer_manager, state_machine, error_handler, rows_to_skip); + skip_scanner.ParseChunk(); + start_iterator = skip_scanner.GetIterator(); } CSVFileScan::CSVFileScan(ClientContext &context, const string &file_path_p, const CSVReaderOptions &options_p, const idx_t file_idx_p, const ReadCSVData &bind_data, const vector &column_ids, - const vector &file_schema) + const vector &file_schema, bool per_file_single_threaded) : file_path(file_path_p), file_idx(file_idx_p), error_handler(make_shared_ptr(options_p.ignore_errors.GetValue())), options(options_p) { auto multi_file_reader = MultiFileReader::CreateDefault("CSV Scan"); @@ -71,12 +85,13 @@ CSVFileScan::CSVFileScan(ClientContext &context, const string &file_path_p, cons file_path, context, nullptr); InitializeFileNamesTypes(); + SetStart(); return; } } // Initialize Buffer Manager - buffer_manager = make_shared_ptr(context, options, file_path, file_idx); + buffer_manager = make_shared_ptr(context, options, file_path, file_idx, per_file_single_threaded); // Initialize On Disk and Size of file on_disk_file = buffer_manager->file_handle->OnDiskFile(); file_size = buffer_manager->file_handle->FileSize(); @@ -98,6 +113,7 @@ CSVFileScan::CSVFileScan(ClientContext &context, const string &file_path_p, cons multi_file_reader->InitializeReader(*this, options.file_options, bind_data.reader_bind, bind_data.return_types, bind_data.return_names, column_ids, nullptr, file_path, context, nullptr); InitializeFileNamesTypes(); + SetStart(); return; } // Sniff it (We only really care about dialect detection, if types or number of columns are different this will @@ -129,6 +145,7 @@ CSVFileScan::CSVFileScan(ClientContext &context, const string &file_path_p, cons multi_file_reader->InitializeReader(*this, options.file_options, bind_data.reader_bind, bind_data.return_types, bind_data.return_names, column_ids, nullptr, file_path, context, nullptr); InitializeFileNamesTypes(); + SetStart(); } CSVFileScan::CSVFileScan(ClientContext &context, const string &file_name, CSVReaderOptions &options_p) @@ -156,6 +173,7 @@ CSVFileScan::CSVFileScan(ClientContext &context, const string &file_name, CSVRea // Initialize State Machine state_machine = make_shared_ptr( state_machine_cache.Get(options.dialect_options.state_machine_options), options); + SetStart(); } void CSVFileScan::InitializeFileNamesTypes() { diff --git a/src/execution/operator/csv_scanner/table_function/global_csv_state.cpp b/src/execution/operator/csv_scanner/table_function/global_csv_state.cpp index acf19effc24..16895bc40c3 100644 --- a/src/execution/operator/csv_scanner/table_function/global_csv_state.cpp +++ b/src/execution/operator/csv_scanner/table_function/global_csv_state.cpp @@ -1,9 +1,11 @@ #include "duckdb/execution/operator/csv_scanner/global_csv_state.hpp" -#include "duckdb/main/client_data.hpp" -#include "duckdb/execution/operator/csv_scanner/scanner_boundary.hpp" + #include "duckdb/execution/operator/csv_scanner/csv_sniffer.hpp" +#include "duckdb/execution/operator/csv_scanner/scanner_boundary.hpp" +#include "duckdb/execution/operator/csv_scanner/skip_scanner.hpp" #include "duckdb/execution/operator/persistent/csv_rejects_table.hpp" #include "duckdb/main/appender.hpp" +#include "duckdb/main/client_data.hpp" namespace duckdb { @@ -22,7 +24,7 @@ CSVGlobalState::CSVGlobalState(ClientContext &context_p, const shared_ptr(context, files[0], options, 0U, bind_data, column_ids, file_schema)); + make_uniq(context, files[0], options, 0U, bind_data, column_ids, file_schema, false)); }; // There are situations where we only support single threaded scanning bool many_csv_files = files.size() > 1 && files.size() > system_threads * 2; @@ -30,13 +32,13 @@ CSVGlobalState::CSVGlobalState(ClientContext &context_p, const shared_ptrbuffer_manager->GetBuffer(0)->actual_size; - current_boundary = CSVIterator(0, 0, 0, 0, buffer_size); + current_boundary = file_scans.back()->start_iterator; + current_boundary.SetCurrentBoundaryToPosition(single_threaded); + if (current_boundary.done && context.client_data->debug_set_max_line_length) { + context.client_data->debug_max_line_length = current_boundary.pos.buffer_pos; } - current_buffer_in_use = make_shared_ptr(*file_scans.back()->buffer_manager, 0); + current_buffer_in_use = + make_shared_ptr(*file_scans.back()->buffer_manager, current_boundary.GetBufferIdx()); } double CSVGlobalState::GetProgress(const ReadCSVData &bind_data_p) const { @@ -68,8 +70,12 @@ unique_ptr CSVGlobalState::Next(optional_ptr parallel_lock(main_mutex); file_scans.emplace_back(make_shared_ptr(context, bind_data.files[cur_idx], bind_data.options, - cur_idx, bind_data, column_ids, file_schema)); + cur_idx, bind_data, column_ids, file_schema, true)); current_file = file_scans.back(); + current_boundary = current_file->start_iterator; + current_boundary.SetCurrentBoundaryToPosition(single_threaded); + current_buffer_in_use = + make_shared_ptr(*file_scans.back()->buffer_manager, current_boundary.GetBufferIdx()); } if (previous_scanner) { lock_guard parallel_lock(main_mutex); @@ -113,11 +119,12 @@ unique_ptr CSVGlobalState::Next(optional_ptr(context, bind_data.files[current_file_idx], bind_data.options, current_file_idx, bind_data, - column_ids, file_schema)); + column_ids, file_schema, false)); // And re-start the boundary-iterator - auto buffer_size = file_scans.back()->buffer_manager->GetBuffer(0)->actual_size; - current_boundary = CSVIterator(current_file_idx, 0, 0, 0, buffer_size); - current_buffer_in_use = make_shared_ptr(*file_scans.back()->buffer_manager, 0); + current_boundary = file_scans.back()->start_iterator; + current_boundary.SetCurrentBoundaryToPosition(single_threaded); + current_buffer_in_use = + make_shared_ptr(*file_scans.back()->buffer_manager, current_boundary.GetBufferIdx()); } else { // If not we are done with this CSV Scanning finished = true; diff --git a/src/execution/operator/csv_scanner/util/csv_reader_options.cpp b/src/execution/operator/csv_scanner/util/csv_reader_options.cpp index ded31aee836..5e077a027e7 100644 --- a/src/execution/operator/csv_scanner/util/csv_reader_options.cpp +++ b/src/execution/operator/csv_scanner/util/csv_reader_options.cpp @@ -89,8 +89,8 @@ void CSVReaderOptions::SetEscape(const string &input) { this->dialect_options.state_machine_options.escape.Set(escape_str[0]); } -int64_t CSVReaderOptions::GetSkipRows() const { - return NumericCast(this->dialect_options.skip_rows.GetValue()); +idx_t CSVReaderOptions::GetSkipRows() const { + return NumericCast(this->dialect_options.skip_rows.GetValue()); } void CSVReaderOptions::SetSkipRows(int64_t skip_rows) { @@ -591,7 +591,7 @@ void CSVReaderOptions::ToNamedParameters(named_parameter_map_t &named_params) { } named_params["max_line_size"] = Value::BIGINT(NumericCast(maximum_line_size)); if (dialect_options.skip_rows.IsSetByUser()) { - named_params["skip"] = Value::BIGINT(GetSkipRows()); + named_params["skip"] = Value::UBIGINT(GetSkipRows()); } named_params["null_padding"] = Value::BOOLEAN(null_padding); named_params["parallel"] = Value::BOOLEAN(parallel); diff --git a/src/execution/operator/helper/physical_transaction.cpp b/src/execution/operator/helper/physical_transaction.cpp index 9361cbd5428..8846cfffc34 100644 --- a/src/execution/operator/helper/physical_transaction.cpp +++ b/src/execution/operator/helper/physical_transaction.cpp @@ -28,6 +28,9 @@ SourceResultType PhysicalTransaction::GetData(ExecutionContext &context, DataChu // preserving the transaction context for the next query client.transaction.SetAutoCommit(false); auto &config = DBConfig::GetConfig(context.client); + if (info->modifier == TransactionModifierType::TRANSACTION_READ_ONLY) { + client.transaction.SetReadOnly(); + } if (config.options.immediate_transaction_mode) { // if immediate transaction mode is enabled then start all transactions immediately auto databases = DatabaseManager::Get(client).GetDatabases(client); diff --git a/src/execution/operator/join/physical_hash_join.cpp b/src/execution/operator/join/physical_hash_join.cpp index e9d880ec56f..f2980944dbb 100644 --- a/src/execution/operator/join/physical_hash_join.cpp +++ b/src/execution/operator/join/physical_hash_join.cpp @@ -533,6 +533,7 @@ class HashJoinOperatorState : public CachingOperatorState { bool initialized; JoinHashTable::ProbeSpillLocalAppendState spill_state; + JoinHashTable::ProbeState probe_state; //! Chunk to sink data into for external join DataChunk spill_chunk; @@ -610,10 +611,11 @@ OperatorResultType PhysicalHashJoin::ExecuteInternal(ExecutionContext &context, // perform the actual probe if (sink.external) { - state.scan_structure = sink.hash_table->ProbeAndSpill(state.join_keys, state.join_key_state, input, - *sink.probe_spill, state.spill_state, state.spill_chunk); + state.scan_structure = + sink.hash_table->ProbeAndSpill(state.join_keys, state.join_key_state, state.probe_state, input, + *sink.probe_spill, state.spill_state, state.spill_chunk); } else { - state.scan_structure = sink.hash_table->Probe(state.join_keys, state.join_key_state); + state.scan_structure = sink.hash_table->Probe(state.join_keys, state.join_key_state, state.probe_state); } state.scan_structure->Next(state.join_keys, input, chunk); return OperatorResultType::HAVE_MORE_OUTPUT; @@ -716,11 +718,13 @@ class HashJoinLocalSourceState : public LocalSourceState { DataChunk join_keys; DataChunk payload; TupleDataChunkState join_key_state; + //! Column indices to easily reference the join keys/payload columns in probe_chunk vector join_key_indices; vector payload_indices; //! Scan structure for the external probe unique_ptr scan_structure; + JoinHashTable::ProbeState probe_state; bool empty_ht_probe_in_progress; //! Chunks assigned to this thread for a full/outer scan @@ -991,7 +995,7 @@ void HashJoinLocalSourceState::ExternalProbe(HashJoinGlobalSinkState &sink, Hash } // Perform the probe - scan_structure = sink.hash_table->Probe(join_keys, join_key_state, precomputed_hashes); + scan_structure = sink.hash_table->Probe(join_keys, join_key_state, probe_state, precomputed_hashes); scan_structure->Next(join_keys, payload, chunk); } diff --git a/src/execution/operator/persistent/physical_batch_copy_to_file.cpp b/src/execution/operator/persistent/physical_batch_copy_to_file.cpp index 17f4e0e4026..f27799b58e9 100644 --- a/src/execution/operator/persistent/physical_batch_copy_to_file.cpp +++ b/src/execution/operator/persistent/physical_batch_copy_to_file.cpp @@ -1,14 +1,16 @@ #include "duckdb/execution/operator/persistent/physical_batch_copy_to_file.hpp" -#include "duckdb/execution/operator/persistent/physical_copy_to_file.hpp" -#include "duckdb/parallel/base_pipeline_event.hpp" -#include "duckdb/common/vector_operations/vector_operations.hpp" -#include "duckdb/common/types/batched_data_collection.hpp" + #include "duckdb/common/allocator.hpp" #include "duckdb/common/queue.hpp" -#include "duckdb/storage/buffer_manager.hpp" +#include "duckdb/common/types/batched_data_collection.hpp" +#include "duckdb/common/vector_operations/vector_operations.hpp" #include "duckdb/execution/operator/persistent/batch_memory_manager.hpp" #include "duckdb/execution/operator/persistent/batch_task_manager.hpp" +#include "duckdb/execution/operator/persistent/physical_copy_to_file.hpp" +#include "duckdb/parallel/base_pipeline_event.hpp" #include "duckdb/parallel/executor_task.hpp" +#include "duckdb/storage/buffer_manager.hpp" + #include namespace duckdb { @@ -605,7 +607,20 @@ SourceResultType PhysicalBatchCopyToFile::GetData(ExecutionContext &context, Dat auto &g = sink_state->Cast(); chunk.SetCardinality(1); - chunk.SetValue(0, 0, Value::BIGINT(NumericCast(g.rows_copied.load()))); + switch (return_type) { + case CopyFunctionReturnType::CHANGED_ROWS: + chunk.SetValue(0, 0, Value::BIGINT(NumericCast(g.rows_copied.load()))); + break; + case CopyFunctionReturnType::CHANGED_ROWS_AND_FILE_LIST: { + chunk.SetValue(0, 0, Value::BIGINT(NumericCast(g.rows_copied.load()))); + auto fp = use_tmp_file ? PhysicalCopyToFile::GetNonTmpFile(context.client, file_path) : file_path; + chunk.SetValue(1, 0, Value::LIST(LogicalType::VARCHAR, {fp})); + break; + } + default: + throw NotImplementedException("Unknown CopyFunctionReturnType"); + } + return SourceResultType::FINISHED; } diff --git a/src/execution/operator/persistent/physical_copy_to_file.cpp b/src/execution/operator/persistent/physical_copy_to_file.cpp index 1e3875734e6..fd6416cb95a 100644 --- a/src/execution/operator/persistent/physical_copy_to_file.cpp +++ b/src/execution/operator/persistent/physical_copy_to_file.cpp @@ -7,7 +7,6 @@ #include "duckdb/common/types/uuid.hpp" #include "duckdb/common/value_operations/value_operations.hpp" #include "duckdb/common/vector_operations/vector_operations.hpp" -#include "duckdb/storage/storage_lock.hpp" #include @@ -57,6 +56,8 @@ class CopyToFunctionGlobalState : public GlobalSinkState { unordered_set created_directories; //! shared state for HivePartitionedColumnData shared_ptr partition_state; + //! File names + vector file_names; void CreateDir(const string &dir_path, FileSystem &fs) { if (created_directories.find(dir_path) != created_directories.end()) { @@ -82,6 +83,11 @@ class CopyToFunctionGlobalState : public GlobalSinkState { return path; } + void AddFileName(const StorageLockKey &l, const string &file_name) { + D_ASSERT(l.GetType() == StorageLockType::EXCLUSIVE); + file_names.emplace_back(file_name); + } + void FinalizePartition(ClientContext &context, const PhysicalCopyToFile &op, PartitionWriteInfo &info) { if (!info.global_state) { // already finalized @@ -101,7 +107,7 @@ class CopyToFunctionGlobalState : public GlobalSinkState { PartitionWriteInfo &GetPartitionWriteInfo(ExecutionContext &context, const PhysicalCopyToFile &op, const vector &values) { - auto l = lock.GetExclusiveLock(); + auto global_lock = lock.GetExclusiveLock(); // check if we have already started writing this partition auto entry = active_partitioned_writes.find(values); if (entry != active_partitioned_writes.end()) { @@ -113,6 +119,19 @@ class CopyToFunctionGlobalState : public GlobalSinkState { auto trimmed_path = op.GetTrimmedPath(context.client); string hive_path = GetOrCreateDirectory(op.partition_columns, op.names, values, trimmed_path, fs); string full_path(op.filename_pattern.CreateFilename(fs, hive_path, op.file_extension, 0)); + if (op.overwrite_mode == CopyOverwriteMode::COPY_APPEND) { + // when appending, we first check if the file exists + while (fs.FileExists(full_path)) { + // file already exists - re-generate name + if (!op.filename_pattern.HasUUID()) { + throw InternalException("CopyOverwriteMode::COPY_APPEND without {uuid} - and file exists"); + } + full_path = op.filename_pattern.CreateFilename(fs, hive_path, op.file_extension, 0); + } + } + if (op.return_type == CopyFunctionReturnType::CHANGED_ROWS_AND_FILE_LIST) { + AddFileName(*global_lock, full_path); + } // initialize writes auto info = make_uniq(); info->global_state = op.function.copy_to_initialize_global(context.client, *op.bind_data, full_path); @@ -205,12 +224,15 @@ class CopyToFunctionLocalState : public LocalSinkState { } }; -unique_ptr PhysicalCopyToFile::CreateFileState(ClientContext &context, - GlobalSinkState &sink) const { +unique_ptr PhysicalCopyToFile::CreateFileState(ClientContext &context, GlobalSinkState &sink, + StorageLockKey &global_lock) const { auto &g = sink.Cast(); idx_t this_file_offset = g.last_file_offset++; auto &fs = FileSystem::GetFileSystem(context); string output_path(filename_pattern.CreateFilename(fs, file_path, file_extension, this_file_offset)); + if (return_type == CopyFunctionReturnType::CHANGED_ROWS_AND_FILE_LIST) { + g.AddFileName(global_lock, output_path); + } return function.copy_to_initialize_global(context, *bind_data, output_path); } @@ -227,7 +249,8 @@ unique_ptr PhysicalCopyToFile::GetLocalSinkState(ExecutionContex } void CheckDirectory(FileSystem &fs, const string &file_path, CopyOverwriteMode overwrite_mode) { - if (overwrite_mode == CopyOverwriteMode::COPY_OVERWRITE_OR_IGNORE) { + if (overwrite_mode == CopyOverwriteMode::COPY_OVERWRITE_OR_IGNORE || + overwrite_mode == CopyOverwriteMode::COPY_APPEND) { // with overwrite or ignore we fully ignore the presence of any files instead of erasing them return; } @@ -290,7 +313,8 @@ unique_ptr PhysicalCopyToFile::GetGlobalSinkState(ClientContext auto state = make_uniq(nullptr); if (!per_thread_output && rotate) { - state->global_state = CreateFileState(context, *state); + auto global_lock = state->lock.GetExclusiveLock(); + state->global_state = CreateFileState(context, *state, *global_lock); } if (partition_output) { @@ -300,7 +324,15 @@ unique_ptr PhysicalCopyToFile::GetGlobalSinkState(ClientContext return std::move(state); } - return make_uniq(function.copy_to_initialize_global(context, *bind_data, file_path)); + auto state = + make_uniq(function.copy_to_initialize_global(context, *bind_data, file_path)); + if (use_tmp_file) { + auto global_lock = state->lock.GetExclusiveLock(); + state->AddFileName(*global_lock, file_path); + } else { + state->file_names.emplace_back(file_path); + } + return std::move(state); } //===--------------------------------------------------------------------===// @@ -308,6 +340,15 @@ unique_ptr PhysicalCopyToFile::GetGlobalSinkState(ClientContext //===--------------------------------------------------------------------===// void PhysicalCopyToFile::MoveTmpFile(ClientContext &context, const string &tmp_file_path) { auto &fs = FileSystem::GetFileSystem(context); + auto file_path = GetNonTmpFile(context, tmp_file_path); + if (fs.FileExists(file_path)) { + fs.RemoveFile(file_path); + } + fs.MoveFile(tmp_file_path, file_path); +} + +string PhysicalCopyToFile::GetNonTmpFile(ClientContext &context, const string &tmp_file_path) { + auto &fs = FileSystem::GetFileSystem(context); auto path = StringUtil::GetFilePath(tmp_file_path); auto base = StringUtil::GetFileName(tmp_file_path); @@ -317,11 +358,7 @@ void PhysicalCopyToFile::MoveTmpFile(ClientContext &context, const string &tmp_f base = base.substr(4); } - auto file_path = fs.JoinPath(path, base); - if (fs.FileExists(file_path)) { - fs.RemoveFile(file_path); - } - fs.MoveFile(tmp_file_path, file_path); + return fs.JoinPath(path, base); } PhysicalCopyToFile::PhysicalCopyToFile(vector types, CopyFunction function_p, @@ -334,21 +371,23 @@ SinkResultType PhysicalCopyToFile::Sink(ExecutionContext &context, DataChunk &ch auto &g = input.global_state.Cast(); auto &l = input.local_state.Cast(); + g.rows_copied += chunk.size(); + if (partition_output) { l.AppendToPartition(context, *this, g, chunk); return SinkResultType::NEED_MORE_INPUT; } - g.rows_copied += chunk.size(); - if (per_thread_output) { auto &gstate = l.global_state; if (!gstate) { // Lazily create file state here to prevent creating empty files - gstate = CreateFileState(context.client, *sink_state); + auto global_lock = g.lock.GetExclusiveLock(); + gstate = CreateFileState(context.client, *sink_state, *global_lock); } else if (rotate && function.rotate_next_file(*gstate, *bind_data, file_size_bytes)) { function.copy_to_finalize(context.client, *bind_data, *gstate); - gstate = CreateFileState(context.client, *sink_state); + auto global_lock = g.lock.GetExclusiveLock(); + gstate = CreateFileState(context.client, *sink_state, *global_lock); } function.copy_to_sink(context, *bind_data, *gstate, *l.local_state, chunk); return SinkResultType::NEED_MORE_INPUT; @@ -361,17 +400,17 @@ SinkResultType PhysicalCopyToFile::Sink(ExecutionContext &context, DataChunk &ch // FILE_SIZE_BYTES/rotate is set, but threads write to the same file, synchronize using lock auto &gstate = g.global_state; - auto lock = g.lock.GetExclusiveLock(); + auto global_lock = g.lock.GetExclusiveLock(); if (rotate && function.rotate_next_file(*gstate, *bind_data, file_size_bytes)) { auto owned_gstate = std::move(gstate); - gstate = CreateFileState(context.client, *sink_state); - lock.reset(); + gstate = CreateFileState(context.client, *sink_state, *global_lock); + global_lock.reset(); function.copy_to_finalize(context.client, *bind_data, *owned_gstate); } else { - lock.reset(); + global_lock.reset(); } - lock = g.lock.GetSharedLock(); + global_lock = g.lock.GetSharedLock(); function.copy_to_sink(context, *bind_data, *gstate, *l.local_state, chunk); return SinkResultType::NEED_MORE_INPUT; @@ -438,7 +477,17 @@ SourceResultType PhysicalCopyToFile::GetData(ExecutionContext &context, DataChun auto &g = sink_state->Cast(); chunk.SetCardinality(1); - chunk.SetValue(0, 0, Value::BIGINT(NumericCast(g.rows_copied.load()))); + switch (return_type) { + case CopyFunctionReturnType::CHANGED_ROWS: + chunk.SetValue(0, 0, Value::BIGINT(NumericCast(g.rows_copied.load()))); + break; + case CopyFunctionReturnType::CHANGED_ROWS_AND_FILE_LIST: + chunk.SetValue(0, 0, Value::BIGINT(NumericCast(g.rows_copied.load()))); + chunk.SetValue(1, 0, Value::LIST(LogicalType::VARCHAR, g.file_names)); + break; + default: + throw NotImplementedException("Unknown CopyFunctionReturnType"); + } return SourceResultType::FINISHED; } diff --git a/src/execution/operator/projection/physical_tableinout_function.cpp b/src/execution/operator/projection/physical_tableinout_function.cpp index d32094f7e2e..f8d585bf58b 100644 --- a/src/execution/operator/projection/physical_tableinout_function.cpp +++ b/src/execution/operator/projection/physical_tableinout_function.cpp @@ -38,7 +38,16 @@ unique_ptr PhysicalTableInOutFunction::GetOperatorState(Execution result->local_state = function.init_local(context, input, gstate.global_state.get()); } if (!projected_input.empty()) { - result->input_chunk.Initialize(context.client, children[0]->types); + vector input_types; + auto &child_types = children[0]->types; + idx_t input_length = child_types.size() - projected_input.size(); + for (idx_t k = 0; k < input_length; k++) { + input_types.push_back(child_types[k]); + } + for (idx_t k = 0; k < projected_input.size(); k++) { + D_ASSERT(projected_input[k] >= input_length); + } + result->input_chunk.Initialize(context.client, input_types); } return std::move(result); } @@ -71,9 +80,8 @@ OperatorResultType PhysicalTableInOutFunction::Execute(ExecutionContext &context } // we are processing a new row: fetch the data for the current row state.input_chunk.Reset(); - D_ASSERT(input.ColumnCount() == state.input_chunk.ColumnCount()); // set up the input data to the table in-out function - for (idx_t col_idx = 0; col_idx < input.ColumnCount(); col_idx++) { + for (idx_t col_idx = 0; col_idx < state.input_chunk.ColumnCount(); col_idx++) { ConstantVector::Reference(state.input_chunk.data[col_idx], input.data[col_idx], state.row_index, 1); } state.input_chunk.SetCardinality(1); @@ -100,6 +108,18 @@ OperatorResultType PhysicalTableInOutFunction::Execute(ExecutionContext &context return OperatorResultType::HAVE_MORE_OUTPUT; } +string PhysicalTableInOutFunction::ParamsToString() const { + string result; + if (function.to_string) { + result = function.to_string(bind_data.get()); + } else { + result += function.name; + } + result += "\n[INFOSEPARATOR]\n"; + result += StringUtil::Format("EC: %llu", estimated_cardinality); + return result; +} + OperatorFinalizeResultType PhysicalTableInOutFunction::FinalExecute(ExecutionContext &context, DataChunk &chunk, GlobalOperatorState &gstate_p, OperatorState &state_p) const { diff --git a/src/execution/operator/scan/physical_table_scan.cpp b/src/execution/operator/scan/physical_table_scan.cpp index ba64b293bae..1bd33d6f918 100644 --- a/src/execution/operator/scan/physical_table_scan.cpp +++ b/src/execution/operator/scan/physical_table_scan.cpp @@ -13,11 +13,12 @@ PhysicalTableScan::PhysicalTableScan(vector types, TableFunction fu unique_ptr bind_data_p, vector returned_types_p, vector column_ids_p, vector projection_ids_p, vector names_p, unique_ptr table_filters_p, - idx_t estimated_cardinality, ExtraOperatorInfo extra_info) + idx_t estimated_cardinality, ExtraOperatorInfo extra_info, + vector parameters_p) : PhysicalOperator(PhysicalOperatorType::TABLE_SCAN, std::move(types), estimated_cardinality), function(std::move(function_p)), bind_data(std::move(bind_data_p)), returned_types(std::move(returned_types_p)), column_ids(std::move(column_ids_p)), projection_ids(std::move(projection_ids_p)), names(std::move(names_p)), - table_filters(std::move(table_filters_p)), extra_info(extra_info) { + table_filters(std::move(table_filters_p)), extra_info(extra_info), parameters(std::move(parameters_p)) { } class TableScanGlobalSourceState : public GlobalSourceState { @@ -32,10 +33,24 @@ class TableScanGlobalSourceState : public GlobalSourceState { } else { max_threads = 1; } + if (op.function.in_out_function) { + // this is an in-out function, we need to setup the input chunk + vector input_types; + for (auto ¶m : op.parameters) { + input_types.push_back(param.type()); + } + input_chunk.Initialize(context, input_types); + for (idx_t c = 0; c < op.parameters.size(); c++) { + input_chunk.data[c].SetValue(0, op.parameters[c]); + } + input_chunk.SetCardinality(1); + } } idx_t max_threads = 0; unique_ptr global_state; + bool in_out_final = false; + DataChunk input_chunk; idx_t MaxThreads() override { return max_threads; @@ -71,7 +86,18 @@ SourceResultType PhysicalTableScan::GetData(ExecutionContext &context, DataChunk auto &state = input.local_state.Cast(); TableFunctionInput data(bind_data.get(), state.local_state.get(), gstate.global_state.get()); - function.function(context.client, data, chunk); + if (function.function) { + function.function(context.client, data, chunk); + } else { + if (gstate.in_out_final) { + function.in_out_function_final(context, data, chunk); + } + function.in_out_function(context, data, gstate.input_chunk, chunk); + if (chunk.size() == 0 && function.in_out_function_final) { + function.in_out_function_final(context, data, chunk); + gstate.in_out_final = true; + } + } return chunk.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT; } diff --git a/src/execution/operator/schema/physical_attach.cpp b/src/execution/operator/schema/physical_attach.cpp index 2b9bfe924fa..ba4a5231b77 100644 --- a/src/execution/operator/schema/physical_attach.cpp +++ b/src/execution/operator/schema/physical_attach.cpp @@ -51,6 +51,14 @@ SourceResultType PhysicalAttach::GetData(ExecutionContext &context, DataChunk &c } } + string extension = ""; + if (FileSystem::IsRemoteFile(path, extension)) { + if (!ExtensionHelper::TryAutoLoadExtension(context.client, extension)) { + throw MissingExtensionException("Attaching path '%s' requires extension '%s' to be loaded", path, + extension); + } + } + // Get the database type and attach the database. db_manager.GetDatabaseType(context.client, *info, config, options); auto attached_db = db_manager.AttachDatabase(context.client, *info, options); diff --git a/src/execution/operator/schema/physical_create_art_index.cpp b/src/execution/operator/schema/physical_create_art_index.cpp index 90eceacf0f7..48731644a37 100644 --- a/src/execution/operator/schema/physical_create_art_index.cpp +++ b/src/execution/operator/schema/physical_create_art_index.cpp @@ -82,9 +82,9 @@ SinkResultType PhysicalCreateARTIndex::SinkUnsorted(Vector &row_identifiers, Ope auto &l_state = input.local_state.Cast(); auto count = l_state.key_chunk.size(); - // get the corresponding row IDs - row_identifiers.Flatten(count); - auto row_ids = FlatVector::GetData(row_identifiers); + UnifiedVectorFormat row_id_data; + row_identifiers.ToUnifiedFormat(count, row_id_data); + auto row_ids = UnifiedVectorFormat::GetData(row_id_data); // insert the row IDs auto &art = l_state.local_index->Cast(); @@ -123,29 +123,29 @@ SinkResultType PhysicalCreateARTIndex::Sink(ExecutionContext &context, DataChunk OperatorSinkInput &input) const { D_ASSERT(chunk.ColumnCount() >= 2); - - // generate the keys for the given input auto &l_state = input.local_state.Cast(); l_state.key_chunk.ReferenceColumns(chunk, l_state.key_column_ids); l_state.arena_allocator.Reset(); - ART::GenerateKeys(l_state.arena_allocator, l_state.key_chunk, l_state.keys); - // insert the keys and their corresponding row IDs + // Insert the keys and their corresponding row identifiers. auto &row_identifiers = chunk.data[chunk.ColumnCount() - 1]; if (sorted) { + ART::GenerateKeys(l_state.arena_allocator, l_state.key_chunk, l_state.keys); return SinkSorted(row_identifiers, input); } + + ART::GenerateKeys(l_state.arena_allocator, l_state.key_chunk, l_state.keys); return SinkUnsorted(row_identifiers, input); } SinkCombineResultType PhysicalCreateARTIndex::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const { - auto &gstate = input.global_state.Cast(); - auto &lstate = input.local_state.Cast(); + auto &g_state = input.global_state.Cast(); + auto &l_state = input.local_state.Cast(); // merge the local index into the global index - if (!gstate.global_index->MergeIndexes(*lstate.local_index)) { + if (!g_state.global_index->MergeIndexes(*l_state.local_index)) { throw ConstraintException("Data contains duplicates on indexed column(s)"); } diff --git a/src/execution/physical_plan/plan_copy_to_file.cpp b/src/execution/physical_plan/plan_copy_to_file.cpp index 8a3f4ecefad..8c26a0ea0eb 100644 --- a/src/execution/physical_plan/plan_copy_to_file.cpp +++ b/src/execution/physical_plan/plan_copy_to_file.cpp @@ -1,5 +1,5 @@ -#include "duckdb/execution/operator/persistent/physical_copy_to_file.hpp" #include "duckdb/execution/operator/persistent/physical_batch_copy_to_file.hpp" +#include "duckdb/execution/operator/persistent/physical_copy_to_file.hpp" #include "duckdb/execution/physical_plan_generator.hpp" #include "duckdb/planner/operator/logical_copy_to_file.hpp" @@ -36,6 +36,7 @@ unique_ptr PhysicalPlanGenerator::CreatePlan(LogicalCopyToFile copy->file_path = op.file_path; copy->use_tmp_file = op.use_tmp_file; copy->children.push_back(std::move(plan)); + copy->return_type = op.return_type; return std::move(copy); } // COPY from select statement to file @@ -50,6 +51,7 @@ unique_ptr PhysicalPlanGenerator::CreatePlan(LogicalCopyToFile copy->file_size_bytes = op.file_size_bytes; } copy->rotate = op.rotate; + copy->return_type = op.return_type; copy->partition_output = op.partition_output; copy->partition_columns = op.partition_columns; copy->names = op.names; diff --git a/src/execution/physical_plan/plan_get.cpp b/src/execution/physical_plan/plan_get.cpp index e7ec54376a2..639f49affb3 100644 --- a/src/execution/physical_plan/plan_get.cpp +++ b/src/execution/physical_plan/plan_get.cpp @@ -1,8 +1,11 @@ +#include "duckdb/execution/operator/scan/physical_expression_scan.hpp" +#include "duckdb/execution/operator/scan/physical_dummy_scan.hpp" #include "duckdb/execution/operator/projection/physical_projection.hpp" #include "duckdb/execution/operator/projection/physical_tableinout_function.hpp" #include "duckdb/execution/operator/scan/physical_table_scan.hpp" #include "duckdb/execution/physical_plan_generator.hpp" #include "duckdb/function/table/table_scan.hpp" +#include "duckdb/planner/expression/bound_cast_expression.hpp" #include "duckdb/planner/expression/bound_constant_expression.hpp" #include "duckdb/planner/expression/bound_reference_expression.hpp" #include "duckdb/planner/operator/logical_get.hpp" @@ -31,11 +34,41 @@ unique_ptr CreateTableFilterSet(TableFilterSet &table_filters, v unique_ptr PhysicalPlanGenerator::CreatePlan(LogicalGet &op) { if (!op.children.empty()) { + auto child_node = CreatePlan(std::move(op.children[0])); // this is for table producing functions that consume subquery results - D_ASSERT(op.children.size() == 1); + // push a projection node with casts if required + if (child_node->types.size() < op.input_table_types.size()) { + throw InternalException( + "Mismatch between input table types and child node types - expected %llu but got %llu", + op.input_table_types.size(), child_node->types.size()); + } + vector return_types; + vector> expressions; + bool any_cast_required = false; + for (idx_t proj_idx = 0; proj_idx < child_node->types.size(); proj_idx++) { + auto ref = make_uniq(child_node->types[proj_idx], proj_idx); + auto &target_type = + proj_idx < op.input_table_types.size() ? op.input_table_types[proj_idx] : child_node->types[proj_idx]; + if (child_node->types[proj_idx] != target_type) { + // cast is required - push a cast + any_cast_required = true; + auto cast = BoundCastExpression::AddCastToType(context, std::move(ref), target_type); + expressions.push_back(std::move(cast)); + } else { + expressions.push_back(std::move(ref)); + } + return_types.push_back(target_type); + } + if (any_cast_required) { + auto proj = make_uniq(std::move(return_types), std::move(expressions), + child_node->estimated_cardinality); + proj->children.push_back(std::move(child_node)); + child_node = std::move(proj); + } + auto node = make_uniq(op.types, op.function, std::move(op.bind_data), op.column_ids, op.estimated_cardinality, std::move(op.projected_input)); - node->children.push_back(CreatePlan(std::move(op.children[0]))); + node->children.push_back(std::move(child_node)); return std::move(node); } if (!op.projected_input.empty()) { @@ -53,9 +86,10 @@ unique_ptr PhysicalPlanGenerator::CreatePlan(LogicalGet &op) { // create the table scan node if (!op.function.projection_pushdown) { // function does not support projection pushdown - auto node = make_uniq(op.returned_types, op.function, std::move(op.bind_data), - op.returned_types, op.column_ids, vector(), op.names, - std::move(table_filters), op.estimated_cardinality, op.extra_info); + auto node = + make_uniq(op.returned_types, op.function, std::move(op.bind_data), op.returned_types, + op.column_ids, vector(), op.names, std::move(table_filters), + op.estimated_cardinality, op.extra_info, std::move(op.parameters)); // first check if an additional projection is necessary if (op.column_ids.size() == op.returned_types.size()) { bool projection_necessary = false; @@ -93,7 +127,7 @@ unique_ptr PhysicalPlanGenerator::CreatePlan(LogicalGet &op) { } else { return make_uniq(op.types, op.function, std::move(op.bind_data), op.returned_types, op.column_ids, op.projection_ids, op.names, std::move(table_filters), - op.estimated_cardinality, op.extra_info); + op.estimated_cardinality, op.extra_info, std::move(op.parameters)); } } diff --git a/src/execution/physical_plan/plan_limit.cpp b/src/execution/physical_plan/plan_limit.cpp index e10764cc336..508f1c889c8 100644 --- a/src/execution/physical_plan/plan_limit.cpp +++ b/src/execution/physical_plan/plan_limit.cpp @@ -7,10 +7,27 @@ namespace duckdb { -bool UseBatchLimit(BoundLimitNode &limit_val, BoundLimitNode &offset_val) { +bool UseBatchLimit(PhysicalOperator &child_node, BoundLimitNode &limit_val, BoundLimitNode &offset_val) { #ifdef DUCKDB_ALTERNATIVE_VERIFY return true; #else + // we only want to use the batch limit when we are executing a complex query (e.g. involving a filter or join) + // if we are doing a limit over a table scan we are otherwise scanning a lot of rows just to throw them away + reference current_ref(child_node); + bool finished = false; + while (!finished) { + auto ¤t_op = current_ref.get(); + switch (current_op.type) { + case PhysicalOperatorType::TABLE_SCAN: + return false; + case PhysicalOperatorType::PROJECTION: + current_ref = *current_op.children[0]; + break; + default: + finished = true; + break; + } + } // 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; @@ -48,7 +65,7 @@ unique_ptr PhysicalPlanGenerator::CreatePlan(LogicalLimit &op) op.estimated_cardinality, true); } else { // maintaining insertion order is important - if (UseBatchIndex(*plan) && UseBatchLimit(op.limit_val, op.offset_val)) { + if (UseBatchIndex(*plan) && UseBatchLimit(*plan, 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); diff --git a/src/execution/radix_partitioned_hashtable.cpp b/src/execution/radix_partitioned_hashtable.cpp index a204bd7c12f..27e4190e66b 100644 --- a/src/execution/radix_partitioned_hashtable.cpp +++ b/src/execution/radix_partitioned_hashtable.cpp @@ -6,6 +6,7 @@ #include "duckdb/common/types/row/tuple_data_iterator.hpp" #include "duckdb/execution/aggregate_hashtable.hpp" #include "duckdb/execution/executor.hpp" +#include "duckdb/execution/ht_entry.hpp" #include "duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp" #include "duckdb/main/config.hpp" #include "duckdb/parallel/event.hpp" @@ -205,7 +206,7 @@ RadixHTGlobalSinkState::RadixHTGlobalSinkState(ClientContext &context_p, const R auto num_partitions = RadixPartitioning::NumberOfPartitions(config.GetRadixBits()); auto count_per_partition = ht_count / num_partitions; auto blocks_per_partition = (count_per_partition + tuples_per_block) / tuples_per_block + 1; - auto ht_size = blocks_per_partition * Storage::BLOCK_ALLOC_SIZE + config.sink_capacity * sizeof(aggr_ht_entry_t); + auto ht_size = blocks_per_partition * Storage::BLOCK_ALLOC_SIZE + config.sink_capacity * sizeof(ht_entry_t); // This really is the minimum reservation that we can do auto num_threads = NumericCast(TaskScheduler::GetScheduler(context).NumberOfThreads()); @@ -309,7 +310,7 @@ idx_t RadixHTConfig::SinkCapacity(ClientContext &context) { 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 - const auto size_per_entry = sizeof(aggr_ht_entry_t) * GroupedAggregateHashTable::LOAD_FACTOR; + const auto size_per_entry = sizeof(ht_entry_t) * GroupedAggregateHashTable::LOAD_FACTOR; const auto capacity = NextPowerOfTwo(NumericCast(static_cast(cache_per_active_thread) / size_per_entry)); @@ -369,7 +370,7 @@ 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); + const auto total_size = partitioned_data->SizeInBytes() + ht.Capacity() * sizeof(ht_entry_t); idx_t thread_limit = temporary_memory_state.GetReservation() / gstate.number_of_threads; if (total_size > thread_limit) { // We're over the thread memory limit @@ -524,7 +525,7 @@ void RadixPartitionedHashTable::Finalize(ClientContext &context, GlobalSinkState auto &partition = uncombined_partition_data[i]; auto partition_size = partition->SizeInBytes() + - GroupedAggregateHashTable::GetCapacityForCount(partition->Count()) * sizeof(aggr_ht_entry_t); + GroupedAggregateHashTable::GetCapacityForCount(partition->Count()) * sizeof(ht_entry_t); gstate.max_partition_size = MaxValue(gstate.max_partition_size, partition_size); gstate.partitions.emplace_back(make_uniq(std::move(partition))); @@ -724,7 +725,7 @@ void RadixHTLocalSourceState::Finalize(RadixHTGlobalSinkState &sink, RadixHTGlob const idx_t thread_limit = NumericCast(0.6 * double(memory_limit) / double(n_threads)); const idx_t size_per_entry = partition.data->SizeInBytes() / MaxValue(partition.data->Count(), 1) + - idx_t(GroupedAggregateHashTable::LOAD_FACTOR * sizeof(aggr_ht_entry_t)); + idx_t(GroupedAggregateHashTable::LOAD_FACTOR * sizeof(ht_entry_t)); // but not lower than the initial capacity const auto capacity_limit = MaxValue(NextPowerOfTwo(thread_limit / size_per_entry), GroupedAggregateHashTable::InitialCapacity()); diff --git a/src/execution/window_executor.cpp b/src/execution/window_executor.cpp index 4d6b9b099c3..e649ff2efb1 100644 --- a/src/execution/window_executor.cpp +++ b/src/execution/window_executor.cpp @@ -193,7 +193,7 @@ struct WindowColumnIterator { template struct OperationCompare : public std::function { inline bool operator()(const T &lhs, const T &val) const { - return OP::template Operation(lhs, val); + return OP::template Operation(lhs, val); } }; diff --git a/src/function/CMakeLists.txt b/src/function/CMakeLists.txt index 15188f77572..b2529c8d8ca 100644 --- a/src/function/CMakeLists.txt +++ b/src/function/CMakeLists.txt @@ -10,6 +10,7 @@ add_library_unity( built_in_functions.cpp cast_rules.cpp compression_config.cpp + copy_function.cpp function.cpp function_binder.cpp function_set.cpp diff --git a/src/function/cast_rules.cpp b/src/function/cast_rules.cpp index acbe2eb0295..f6537e235e1 100644 --- a/src/function/cast_rules.cpp +++ b/src/function/cast_rules.cpp @@ -212,6 +212,9 @@ static int64_t ImplicitCastDate(const LogicalType &to) { switch (to.id()) { case LogicalTypeId::TIMESTAMP: case LogicalTypeId::TIMESTAMP_TZ: + case LogicalTypeId::TIMESTAMP_MS: + case LogicalTypeId::TIMESTAMP_NS: + case LogicalTypeId::TIMESTAMP_SEC: return TargetTypeCost(to); default: return -1; diff --git a/src/function/copy_function.cpp b/src/function/copy_function.cpp new file mode 100644 index 00000000000..ac2bc754533 --- /dev/null +++ b/src/function/copy_function.cpp @@ -0,0 +1,27 @@ +#include "duckdb/function/copy_function.hpp" + +namespace duckdb { + +vector GetCopyFunctionReturnNames(CopyFunctionReturnType return_type) { + switch (return_type) { + case CopyFunctionReturnType::CHANGED_ROWS: + return {"Count"}; + case CopyFunctionReturnType::CHANGED_ROWS_AND_FILE_LIST: + return {"Count", "Files"}; + default: + throw NotImplementedException("Unknown CopyFunctionReturnType"); + } +} + +vector GetCopyFunctionReturnLogicalTypes(CopyFunctionReturnType return_type) { + switch (return_type) { + case CopyFunctionReturnType::CHANGED_ROWS: + return {LogicalType::BIGINT}; + case CopyFunctionReturnType::CHANGED_ROWS_AND_FILE_LIST: + return {LogicalType::BIGINT, LogicalType::LIST(LogicalType::VARCHAR)}; + default: + throw NotImplementedException("Unknown CopyFunctionReturnType"); + } +} + +} // namespace duckdb diff --git a/src/function/scalar/list/CMakeLists.txt b/src/function/scalar/list/CMakeLists.txt index cd4412440b1..1ec4ac330f0 100644 --- a/src/function/scalar/list/CMakeLists.txt +++ b/src/function/scalar/list/CMakeLists.txt @@ -1,7 +1,6 @@ add_library_unity( duckdb_func_list_nested OBJECT - list_concat.cpp contains_or_position.cpp list_extract.cpp list_resize.cpp diff --git a/src/function/scalar/list/list_concat.cpp b/src/function/scalar/list/list_concat.cpp deleted file mode 100644 index 880d752640a..00000000000 --- a/src/function/scalar/list/list_concat.cpp +++ /dev/null @@ -1,143 +0,0 @@ -#include "duckdb/common/types/data_chunk.hpp" -#include "duckdb/function/scalar/nested_functions.hpp" -#include "duckdb/planner/expression/bound_function_expression.hpp" -#include "duckdb/planner/expression/bound_parameter_expression.hpp" -#include "duckdb/planner/expression_binder.hpp" -#include "duckdb/planner/expression/bound_cast_expression.hpp" - -namespace duckdb { - -static void ListConcatFunction(DataChunk &args, ExpressionState &state, Vector &result) { - D_ASSERT(args.ColumnCount() == 2); - auto count = args.size(); - - Vector &lhs = args.data[0]; - Vector &rhs = args.data[1]; - if (lhs.GetType().id() == LogicalTypeId::SQLNULL) { - result.Reference(rhs); - return; - } - if (rhs.GetType().id() == LogicalTypeId::SQLNULL) { - result.Reference(lhs); - return; - } - - UnifiedVectorFormat lhs_data; - UnifiedVectorFormat rhs_data; - lhs.ToUnifiedFormat(count, lhs_data); - rhs.ToUnifiedFormat(count, rhs_data); - auto lhs_entries = UnifiedVectorFormat::GetData(lhs_data); - auto rhs_entries = UnifiedVectorFormat::GetData(rhs_data); - - auto lhs_list_size = ListVector::GetListSize(lhs); - auto rhs_list_size = ListVector::GetListSize(rhs); - auto &lhs_child = ListVector::GetEntry(lhs); - auto &rhs_child = ListVector::GetEntry(rhs); - UnifiedVectorFormat lhs_child_data; - UnifiedVectorFormat rhs_child_data; - lhs_child.ToUnifiedFormat(lhs_list_size, lhs_child_data); - rhs_child.ToUnifiedFormat(rhs_list_size, rhs_child_data); - - result.SetVectorType(VectorType::FLAT_VECTOR); - auto result_entries = FlatVector::GetData(result); - auto &result_validity = FlatVector::Validity(result); - - idx_t offset = 0; - for (idx_t i = 0; i < count; i++) { - auto lhs_list_index = lhs_data.sel->get_index(i); - auto rhs_list_index = rhs_data.sel->get_index(i); - if (!lhs_data.validity.RowIsValid(lhs_list_index) && !rhs_data.validity.RowIsValid(rhs_list_index)) { - result_validity.SetInvalid(i); - continue; - } - result_entries[i].offset = offset; - result_entries[i].length = 0; - if (lhs_data.validity.RowIsValid(lhs_list_index)) { - const auto &lhs_entry = lhs_entries[lhs_list_index]; - result_entries[i].length += lhs_entry.length; - ListVector::Append(result, lhs_child, *lhs_child_data.sel, lhs_entry.offset + lhs_entry.length, - lhs_entry.offset); - } - if (rhs_data.validity.RowIsValid(rhs_list_index)) { - const auto &rhs_entry = rhs_entries[rhs_list_index]; - result_entries[i].length += rhs_entry.length; - ListVector::Append(result, rhs_child, *rhs_child_data.sel, rhs_entry.offset + rhs_entry.length, - rhs_entry.offset); - } - offset += result_entries[i].length; - } - D_ASSERT(ListVector::GetListSize(result) == offset); - - if (lhs.GetVectorType() == VectorType::CONSTANT_VECTOR && rhs.GetVectorType() == VectorType::CONSTANT_VECTOR) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -static unique_ptr ListConcatBind(ClientContext &context, ScalarFunction &bound_function, - vector> &arguments) { - D_ASSERT(bound_function.arguments.size() == 2); - - // if either argument is an array, we cast it to a list - arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0])); - arguments[1] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[1])); - - auto &lhs = arguments[0]->return_type; - auto &rhs = arguments[1]->return_type; - - if (lhs.id() == LogicalTypeId::UNKNOWN || rhs.id() == LogicalTypeId::UNKNOWN) { - throw ParameterNotResolvedException(); - } else if (lhs.id() == LogicalTypeId::SQLNULL || rhs.id() == LogicalTypeId::SQLNULL) { - // we mimic postgres behaviour: list_concat(NULL, my_list) = my_list - auto return_type = rhs.id() == LogicalTypeId::SQLNULL ? lhs : rhs; - bound_function.arguments[0] = return_type; - bound_function.arguments[1] = return_type; - bound_function.return_type = return_type; - } else { - D_ASSERT(lhs.id() == LogicalTypeId::LIST); - D_ASSERT(rhs.id() == LogicalTypeId::LIST); - - // Resolve list type - LogicalType child_type = LogicalType::SQLNULL; - for (const auto &argument : arguments) { - auto &next_type = ListType::GetChildType(argument->return_type); - if (!LogicalType::TryGetMaxLogicalType(context, child_type, next_type, child_type)) { - throw BinderException("Cannot concatenate lists of types %s[] and %s[] - an explicit cast is required", - child_type.ToString(), next_type.ToString()); - } - } - auto list_type = LogicalType::LIST(child_type); - - bound_function.arguments[0] = list_type; - bound_function.arguments[1] = list_type; - bound_function.return_type = list_type; - } - return make_uniq(bound_function.return_type); -} - -static unique_ptr ListConcatStats(ClientContext &context, FunctionStatisticsInput &input) { - auto &child_stats = input.child_stats; - D_ASSERT(child_stats.size() == 2); - - auto &left_stats = child_stats[0]; - auto &right_stats = child_stats[1]; - - auto stats = left_stats.ToUnique(); - stats->Merge(right_stats); - - return stats; -} - -ScalarFunction ListConcatFun::GetFunction() { - // the arguments and return types are actually set in the binder function - auto fun = ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::LIST(LogicalType::ANY)}, - LogicalType::LIST(LogicalType::ANY), ListConcatFunction, ListConcatBind, nullptr, - ListConcatStats); - fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING; - return fun; -} - -void ListConcatFun::RegisterFunction(BuiltinFunctions &set) { - set.AddFunction({"list_concat", "list_cat", "array_concat", "array_cat"}, GetFunction()); -} - -} // namespace duckdb diff --git a/src/function/scalar/operators/arithmetic.cpp b/src/function/scalar/operators/arithmetic.cpp index 828395ff529..17cda072388 100644 --- a/src/function/scalar/operators/arithmetic.cpp +++ b/src/function/scalar/operators/arithmetic.cpp @@ -1,3 +1,4 @@ +#include "duckdb/common/enum_util.hpp" #include "duckdb/common/operator/add.hpp" #include "duckdb/common/operator/multiply.hpp" #include "duckdb/common/operator/numeric_binary_operators.hpp" @@ -9,10 +10,10 @@ #include "duckdb/common/types/time.hpp" #include "duckdb/common/types/timestamp.hpp" #include "duckdb/common/vector_operations/vector_operations.hpp" -#include "duckdb/common/enum_util.hpp" +#include "duckdb/function/scalar/nested_functions.hpp" #include "duckdb/function/scalar/operators.hpp" +#include "duckdb/function/scalar/string_functions.hpp" #include "duckdb/planner/expression/bound_function_expression.hpp" -#include "duckdb/function/scalar/nested_functions.hpp" #include diff --git a/src/function/scalar/string/CMakeLists.txt b/src/function/scalar/string/CMakeLists.txt index 360f7b38458..1de617f5c4d 100644 --- a/src/function/scalar/string/CMakeLists.txt +++ b/src/function/scalar/string/CMakeLists.txt @@ -4,6 +4,7 @@ add_library_unity( OBJECT caseconvert.cpp concat.cpp + concat_ws.cpp length.cpp like.cpp nfc_normalize.cpp diff --git a/src/function/scalar/string/caseconvert.cpp b/src/function/scalar/string/caseconvert.cpp index fa5b612f186..b6240d0624d 100644 --- a/src/function/scalar/string/caseconvert.cpp +++ b/src/function/scalar/string/caseconvert.cpp @@ -5,7 +5,7 @@ #include "duckdb/common/vector_operations/unary_executor.hpp" #include "duckdb/planner/expression/bound_function_expression.hpp" -#include "utf8proc.hpp" +#include "utf8proc_wrapper.hpp" #include @@ -58,9 +58,10 @@ static idx_t GetResultLength(const char *input_data, idx_t input_length) { if (input_data[i] & 0x80) { // unicode int sz = 0; - auto codepoint = utf8proc_codepoint(input_data + i, sz); - auto converted_codepoint = IS_UPPER ? utf8proc_toupper(codepoint) : utf8proc_tolower(codepoint); - auto new_sz = utf8proc_codepoint_length(converted_codepoint); + auto codepoint = Utf8Proc::UTF8ToCodepoint(input_data + i, sz); + auto converted_codepoint = + IS_UPPER ? Utf8Proc::CodepointToUpper(codepoint) : Utf8Proc::CodepointToLower(codepoint); + auto new_sz = Utf8Proc::CodepointLength(converted_codepoint); D_ASSERT(new_sz >= 0); output_length += UnsafeNumericCast(new_sz); i += UnsafeNumericCast(sz); @@ -79,9 +80,10 @@ static void CaseConvert(const char *input_data, idx_t input_length, char *result if (input_data[i] & 0x80) { // non-ascii character int sz = 0, new_sz = 0; - auto codepoint = utf8proc_codepoint(input_data + i, sz); - auto converted_codepoint = IS_UPPER ? utf8proc_toupper(codepoint) : utf8proc_tolower(codepoint); - auto success = utf8proc_codepoint_to_utf8(converted_codepoint, new_sz, result_data); + auto codepoint = Utf8Proc::UTF8ToCodepoint(input_data + i, sz); + auto converted_codepoint = + IS_UPPER ? Utf8Proc::CodepointToUpper(codepoint) : Utf8Proc::CodepointToLower(codepoint); + auto success = Utf8Proc::CodepointToUtf8(converted_codepoint, new_sz, result_data); D_ASSERT(success); (void)success; result_data += new_sz; diff --git a/src/function/scalar/string/concat.cpp b/src/function/scalar/string/concat.cpp index 5ad0c9a3ede..9f78af9a23e 100644 --- a/src/function/scalar/string/concat.cpp +++ b/src/function/scalar/string/concat.cpp @@ -4,12 +4,41 @@ #include "duckdb/common/vector_operations/vector_operations.hpp" #include "duckdb/function/scalar/nested_functions.hpp" #include "duckdb/function/scalar/string_functions.hpp" +#include "duckdb/planner/expression/bound_cast_expression.hpp" +#include "duckdb/planner/expression/bound_function_expression.hpp" #include namespace duckdb { -static void ConcatFunction(DataChunk &args, ExpressionState &state, Vector &result) { +struct ConcatFunctionData : public FunctionData { + ConcatFunctionData(const LogicalType &return_type_p, bool is_operator_p) + : return_type(return_type_p), is_operator(is_operator_p) { + } + ~ConcatFunctionData() override; + + LogicalType return_type; + + bool is_operator = false; + +public: + bool Equals(const FunctionData &other_p) const override; + unique_ptr Copy() const override; +}; + +ConcatFunctionData::~ConcatFunctionData() { +} + +bool ConcatFunctionData::Equals(const FunctionData &other_p) const { + auto &other = other_p.Cast(); + return return_type == other.return_type && is_operator == other.is_operator; +} + +unique_ptr ConcatFunctionData::Copy() const { + return make_uniq(return_type, is_operator); +} + +static void StringConcatFunction(DataChunk &args, ExpressionState &state, Vector &result) { result.SetVectorType(VectorType::CONSTANT_VECTOR); // iterate over the vectors to count how large the final string will be idx_t constant_lengths = 0; @@ -114,130 +143,224 @@ static void ConcatOperator(DataChunk &args, ExpressionState &state, Vector &resu }); } -static void TemplatedConcatWS(DataChunk &args, const string_t *sep_data, const SelectionVector &sep_sel, - const SelectionVector &rsel, idx_t count, Vector &result) { - vector result_lengths(args.size(), 0); - vector has_results(args.size(), false); - - // we overallocate here, but this is important for static analysis - auto orrified_data = make_unsafe_uniq_array(args.ColumnCount()); +static void ListConcatFunction(DataChunk &args, ExpressionState &state, Vector &result) { + D_ASSERT(args.ColumnCount() == 2); + auto count = args.size(); - for (idx_t col_idx = 1; col_idx < args.ColumnCount(); col_idx++) { - args.data[col_idx].ToUnifiedFormat(args.size(), orrified_data[col_idx - 1]); + Vector &lhs = args.data[0]; + Vector &rhs = args.data[1]; + if (lhs.GetType().id() == LogicalTypeId::SQLNULL) { + result.Reference(rhs); + return; + } + if (rhs.GetType().id() == LogicalTypeId::SQLNULL) { + result.Reference(lhs); + return; } - // first figure out the lengths - for (idx_t col_idx = 1; col_idx < args.ColumnCount(); col_idx++) { - auto &idata = orrified_data[col_idx - 1]; + UnifiedVectorFormat lhs_data; + UnifiedVectorFormat rhs_data; + lhs.ToUnifiedFormat(count, lhs_data); + rhs.ToUnifiedFormat(count, rhs_data); + auto lhs_entries = UnifiedVectorFormat::GetData(lhs_data); + auto rhs_entries = UnifiedVectorFormat::GetData(rhs_data); - auto input_data = UnifiedVectorFormat::GetData(idata); - for (idx_t i = 0; i < count; i++) { - auto ridx = rsel.get_index(i); - auto sep_idx = sep_sel.get_index(ridx); - auto idx = idata.sel->get_index(ridx); - if (!idata.validity.RowIsValid(idx)) { - continue; - } - if (has_results[ridx]) { - result_lengths[ridx] += sep_data[sep_idx].GetSize(); - } - result_lengths[ridx] += input_data[idx].GetSize(); - has_results[ridx] = true; + auto lhs_list_size = ListVector::GetListSize(lhs); + auto rhs_list_size = ListVector::GetListSize(rhs); + auto &lhs_child = ListVector::GetEntry(lhs); + auto &rhs_child = ListVector::GetEntry(rhs); + UnifiedVectorFormat lhs_child_data; + UnifiedVectorFormat rhs_child_data; + lhs_child.ToUnifiedFormat(lhs_list_size, lhs_child_data); + rhs_child.ToUnifiedFormat(rhs_list_size, rhs_child_data); + + result.SetVectorType(VectorType::FLAT_VECTOR); + auto result_entries = FlatVector::GetData(result); + auto &result_validity = FlatVector::Validity(result); + + idx_t offset = 0; + for (idx_t i = 0; i < count; i++) { + auto lhs_list_index = lhs_data.sel->get_index(i); + auto rhs_list_index = rhs_data.sel->get_index(i); + if (!lhs_data.validity.RowIsValid(lhs_list_index) && !rhs_data.validity.RowIsValid(rhs_list_index)) { + result_validity.SetInvalid(i); + continue; } + result_entries[i].offset = offset; + result_entries[i].length = 0; + if (lhs_data.validity.RowIsValid(lhs_list_index)) { + const auto &lhs_entry = lhs_entries[lhs_list_index]; + result_entries[i].length += lhs_entry.length; + ListVector::Append(result, lhs_child, *lhs_child_data.sel, lhs_entry.offset + lhs_entry.length, + lhs_entry.offset); + } + if (rhs_data.validity.RowIsValid(rhs_list_index)) { + const auto &rhs_entry = rhs_entries[rhs_list_index]; + result_entries[i].length += rhs_entry.length; + ListVector::Append(result, rhs_child, *rhs_child_data.sel, rhs_entry.offset + rhs_entry.length, + rhs_entry.offset); + } + offset += result_entries[i].length; } + D_ASSERT(ListVector::GetListSize(result) == offset); - // first we allocate the empty strings for each of the values - auto result_data = FlatVector::GetData(result); - for (idx_t i = 0; i < count; i++) { - auto ridx = rsel.get_index(i); - // allocate an empty string of the required size - result_data[ridx] = StringVector::EmptyString(result, result_lengths[ridx]); - // we reuse the result_lengths vector to store the currently appended size - result_lengths[ridx] = 0; - has_results[ridx] = false; + if (lhs.GetVectorType() == VectorType::CONSTANT_VECTOR && rhs.GetVectorType() == VectorType::CONSTANT_VECTOR) { + result.SetVectorType(VectorType::CONSTANT_VECTOR); } +} - // now that the empty space for the strings has been allocated, perform the concatenation - for (idx_t col_idx = 1; col_idx < args.ColumnCount(); col_idx++) { - auto &idata = orrified_data[col_idx - 1]; - auto input_data = UnifiedVectorFormat::GetData(idata); - for (idx_t i = 0; i < count; i++) { - auto ridx = rsel.get_index(i); - auto sep_idx = sep_sel.get_index(ridx); - auto idx = idata.sel->get_index(ridx); - if (!idata.validity.RowIsValid(idx)) { - continue; - } - if (has_results[ridx]) { - auto sep_size = sep_data[sep_idx].GetSize(); - auto sep_ptr = sep_data[sep_idx].GetData(); - memcpy(result_data[ridx].GetDataWriteable() + result_lengths[ridx], sep_ptr, sep_size); - result_lengths[ridx] += sep_size; - } - auto input_ptr = input_data[idx].GetData(); - auto input_len = input_data[idx].GetSize(); - memcpy(result_data[ridx].GetDataWriteable() + result_lengths[ridx], input_ptr, input_len); - result_lengths[ridx] += input_len; - has_results[ridx] = true; - } +static void ConcatFunction(DataChunk &args, ExpressionState &state, Vector &result) { + auto &func_expr = state.expr.Cast(); + auto &info = func_expr.bind_info->Cast(); + if (info.return_type.id() == LogicalTypeId::LIST) { + return ListConcatFunction(args, state, result); + } else if (info.is_operator) { + return ConcatOperator(args, state, result); } - for (idx_t i = 0; i < count; i++) { - auto ridx = rsel.get_index(i); - result_data[ridx].Finalize(); + return StringConcatFunction(args, state, result); +} + +static void SetArgumentType(ScalarFunction &bound_function, const LogicalType &type, bool is_operator) { + if (is_operator) { + bound_function.arguments[0] = type; + bound_function.arguments[1] = type; + bound_function.return_type = type; + return; + } + + for (auto &arg : bound_function.arguments) { + arg = type; + } + bound_function.varargs = type; + bound_function.return_type = type; +} + +static void HandleArrayBinding(ClientContext &context, vector> &arguments) { + if (arguments[1]->return_type.id() != LogicalTypeId::ARRAY && + arguments[1]->return_type.id() != LogicalTypeId::SQLNULL) { + throw BinderException("Cannot concatenate types %s and %s", arguments[0]->return_type.ToString(), + arguments[1]->return_type.ToString()); } + + // if either argument is an array, we cast it to a list + arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0])); + arguments[1] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[1])); } -static void ConcatWSFunction(DataChunk &args, ExpressionState &state, Vector &result) { - auto &separator = args.data[0]; - UnifiedVectorFormat vdata; - separator.ToUnifiedFormat(args.size(), vdata); +static unique_ptr HandleListBinding(ClientContext &context, ScalarFunction &bound_function, + vector> &arguments, bool is_operator) { + // list_concat only accepts two arguments + D_ASSERT(arguments.size() == 2); - result.SetVectorType(VectorType::CONSTANT_VECTOR); - for (idx_t col_idx = 0; col_idx < args.ColumnCount(); col_idx++) { - if (args.data[col_idx].GetVectorType() != VectorType::CONSTANT_VECTOR) { - result.SetVectorType(VectorType::FLAT_VECTOR); - break; - } + auto &lhs = arguments[0]->return_type; + auto &rhs = arguments[1]->return_type; + + if (lhs.id() == LogicalTypeId::UNKNOWN || rhs.id() == LogicalTypeId::UNKNOWN) { + throw ParameterNotResolvedException(); + } else if (lhs.id() == LogicalTypeId::SQLNULL || rhs.id() == LogicalTypeId::SQLNULL) { + // we mimic postgres behaviour: list_concat(NULL, my_list) = my_list + auto return_type = rhs.id() == LogicalTypeId::SQLNULL ? lhs : rhs; + SetArgumentType(bound_function, return_type, is_operator); + return make_uniq(bound_function.return_type, is_operator); } - switch (separator.GetVectorType()) { - case VectorType::CONSTANT_VECTOR: { - if (ConstantVector::IsNull(separator)) { - // constant NULL as separator: return constant NULL vector - result.SetVectorType(VectorType::CONSTANT_VECTOR); - ConstantVector::SetNull(result, true); - return; - } - // no null values - auto sel = FlatVector::IncrementalSelectionVector(); - TemplatedConcatWS(args, UnifiedVectorFormat::GetData(vdata), *vdata.sel, *sel, args.size(), result); - return; + if (lhs.id() != LogicalTypeId::LIST || rhs.id() != LogicalTypeId::LIST) { + throw BinderException("Cannot concatenate types %s and %s", lhs.ToString(), rhs.ToString()); } - default: { - // default case: loop over nullmask and create a non-null selection vector - idx_t not_null_count = 0; - SelectionVector not_null_vector(STANDARD_VECTOR_SIZE); - auto &result_mask = FlatVector::Validity(result); - for (idx_t i = 0; i < args.size(); i++) { - if (!vdata.validity.RowIsValid(vdata.sel->get_index(i))) { - result_mask.SetInvalid(i); - } else { - not_null_vector.set_index(not_null_count++, i); - } + + // Resolve list type + LogicalType child_type = LogicalType::SQLNULL; + for (const auto &argument : arguments) { + auto &next_type = ListType::GetChildType(argument->return_type); + if (!LogicalType::TryGetMaxLogicalType(context, child_type, next_type, child_type)) { + throw BinderException("Cannot concatenate lists of types %s[] and %s[] - an explicit cast is required", + child_type.ToString(), next_type.ToString()); } - TemplatedConcatWS(args, UnifiedVectorFormat::GetData(vdata), *vdata.sel, not_null_vector, - not_null_count, result); - return; } + auto list_type = LogicalType::LIST(child_type); + + SetArgumentType(bound_function, list_type, is_operator); + return make_uniq(bound_function.return_type, is_operator); +} + +static void FindFirstTwoArguments(vector> &arguments, LogicalTypeId &first_arg, + LogicalTypeId &second_arg) { + first_arg = arguments[0]->return_type.id(); + second_arg = first_arg; + if (arguments.size() > 1) { + second_arg = arguments[1]->return_type.id(); } } static unique_ptr BindConcatFunction(ClientContext &context, ScalarFunction &bound_function, vector> &arguments) { - for (auto &arg : bound_function.arguments) { - arg = LogicalType::VARCHAR; + LogicalTypeId first_arg; + LogicalTypeId second_arg; + FindFirstTwoArguments(arguments, first_arg, second_arg); + + if (arguments.size() > 2 && (first_arg == LogicalTypeId::ARRAY || first_arg == LogicalTypeId::LIST)) { + throw BinderException("list_concat only accepts two arguments"); } - bound_function.varargs = LogicalType::VARCHAR; - return nullptr; + + if (first_arg == LogicalTypeId::ARRAY || second_arg == LogicalTypeId::ARRAY) { + HandleArrayBinding(context, arguments); + FindFirstTwoArguments(arguments, first_arg, second_arg); + } + + if (first_arg == LogicalTypeId::LIST || second_arg == LogicalTypeId::LIST) { + return HandleListBinding(context, bound_function, arguments, false); + } + + // we can now assume that the input is a string or castable to a string + SetArgumentType(bound_function, LogicalType::VARCHAR, false); + return make_uniq(bound_function.return_type, false); +} + +static unique_ptr BindConcatOperator(ClientContext &context, ScalarFunction &bound_function, + vector> &arguments) { + D_ASSERT(arguments.size() == 2); + + LogicalTypeId lhs; + LogicalTypeId rhs; + FindFirstTwoArguments(arguments, lhs, rhs); + + if (lhs == LogicalTypeId::ARRAY || rhs == LogicalTypeId::ARRAY) { + HandleArrayBinding(context, arguments); + FindFirstTwoArguments(arguments, lhs, rhs); + } + + if (lhs == LogicalTypeId::LIST || rhs == LogicalTypeId::LIST) { + return HandleListBinding(context, bound_function, arguments, true); + } + + // we can now assume that the input is a string or castable to a string + SetArgumentType(bound_function, LogicalType::VARCHAR, true); + return make_uniq(bound_function.return_type, true); +} + +static unique_ptr ListConcatStats(ClientContext &context, FunctionStatisticsInput &input) { + auto &child_stats = input.child_stats; + D_ASSERT(child_stats.size() == 2); + + auto &left_stats = child_stats[0]; + auto &right_stats = child_stats[1]; + + auto stats = left_stats.ToUnique(); + stats->Merge(right_stats); + + return stats; +} + +ScalarFunction ListConcatFun::GetFunction() { + // The arguments and return types are set in the binder function. + auto fun = ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::LIST(LogicalType::ANY)}, + LogicalType::LIST(LogicalType::ANY), ConcatFunction, BindConcatFunction, nullptr, + ListConcatStats); + fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING; + return fun; +} + +void ListConcatFun::RegisterFunction(BuiltinFunctions &set) { + set.AddFunction({"list_concat", "list_cat", "array_concat", "array_cat"}, GetFunction()); } void ConcatFun::RegisterFunction(BuiltinFunctions &set) { @@ -249,34 +372,17 @@ void ConcatFun::RegisterFunction(BuiltinFunctions &set) { // i.e. NULL || 'hello' = NULL // the concat function, however, treats NULL values as an empty string // i.e. concat(NULL, 'hello') = 'hello' - // concat_ws functions similarly to the concat function, except the result is NULL if the separator is NULL - // if the separator is not NULL, however, NULL values are counted as empty string - // there is one separate rule: there are no separators added between NULL values - // so the NULL value and empty string are different! - // e.g.: - // concat_ws(',', NULL, NULL) = "" - // concat_ws(',', '', '') = "," + ScalarFunction concat = - ScalarFunction("concat", {LogicalType::ANY}, LogicalType::VARCHAR, ConcatFunction, BindConcatFunction); + ScalarFunction("concat", {LogicalType::ANY}, LogicalType::ANY, ConcatFunction, BindConcatFunction); concat.varargs = LogicalType::ANY; concat.null_handling = FunctionNullHandling::SPECIAL_HANDLING; set.AddFunction(concat); - ScalarFunctionSet concat_op("||"); - concat_op.AddFunction( - ScalarFunction({LogicalType::ANY, LogicalType::ANY}, LogicalType::VARCHAR, ConcatOperator, BindConcatFunction)); - concat_op.AddFunction(ScalarFunction({LogicalType::BLOB, LogicalType::BLOB}, LogicalType::BLOB, ConcatOperator)); - concat_op.AddFunction(ListConcatFun::GetFunction()); - for (auto &fun : concat_op.functions) { - fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING; - } + ScalarFunction concat_op = ScalarFunction("||", {LogicalType::ANY, LogicalType::ANY}, LogicalType::ANY, + ConcatFunction, BindConcatOperator); + concat.null_handling = FunctionNullHandling::SPECIAL_HANDLING; set.AddFunction(concat_op); - - ScalarFunction concat_ws = ScalarFunction("concat_ws", {LogicalType::VARCHAR, LogicalType::ANY}, - LogicalType::VARCHAR, ConcatWSFunction, BindConcatFunction); - concat_ws.varargs = LogicalType::ANY; - concat_ws.null_handling = FunctionNullHandling::SPECIAL_HANDLING; - set.AddFunction(concat_ws); } } // namespace duckdb diff --git a/src/function/scalar/string/concat_ws.cpp b/src/function/scalar/string/concat_ws.cpp new file mode 100644 index 00000000000..873eb56d0d7 --- /dev/null +++ b/src/function/scalar/string/concat_ws.cpp @@ -0,0 +1,149 @@ +#include "duckdb/function/scalar/string_functions.hpp" + +#include + +namespace duckdb { + +static void TemplatedConcatWS(DataChunk &args, const string_t *sep_data, const SelectionVector &sep_sel, + const SelectionVector &rsel, idx_t count, Vector &result) { + vector result_lengths(args.size(), 0); + vector has_results(args.size(), false); + + // we overallocate here, but this is important for static analysis + auto orrified_data = make_unsafe_uniq_array(args.ColumnCount()); + + for (idx_t col_idx = 1; col_idx < args.ColumnCount(); col_idx++) { + args.data[col_idx].ToUnifiedFormat(args.size(), orrified_data[col_idx - 1]); + } + + // first figure out the lengths + for (idx_t col_idx = 1; col_idx < args.ColumnCount(); col_idx++) { + auto &idata = orrified_data[col_idx - 1]; + + auto input_data = UnifiedVectorFormat::GetData(idata); + for (idx_t i = 0; i < count; i++) { + auto ridx = rsel.get_index(i); + auto sep_idx = sep_sel.get_index(ridx); + auto idx = idata.sel->get_index(ridx); + if (!idata.validity.RowIsValid(idx)) { + continue; + } + if (has_results[ridx]) { + result_lengths[ridx] += sep_data[sep_idx].GetSize(); + } + result_lengths[ridx] += input_data[idx].GetSize(); + has_results[ridx] = true; + } + } + + // first we allocate the empty strings for each of the values + auto result_data = FlatVector::GetData(result); + for (idx_t i = 0; i < count; i++) { + auto ridx = rsel.get_index(i); + // allocate an empty string of the required size + result_data[ridx] = StringVector::EmptyString(result, result_lengths[ridx]); + // we reuse the result_lengths vector to store the currently appended size + result_lengths[ridx] = 0; + has_results[ridx] = false; + } + + // now that the empty space for the strings has been allocated, perform the concatenation + for (idx_t col_idx = 1; col_idx < args.ColumnCount(); col_idx++) { + auto &idata = orrified_data[col_idx - 1]; + auto input_data = UnifiedVectorFormat::GetData(idata); + for (idx_t i = 0; i < count; i++) { + auto ridx = rsel.get_index(i); + auto sep_idx = sep_sel.get_index(ridx); + auto idx = idata.sel->get_index(ridx); + if (!idata.validity.RowIsValid(idx)) { + continue; + } + if (has_results[ridx]) { + auto sep_size = sep_data[sep_idx].GetSize(); + auto sep_ptr = sep_data[sep_idx].GetData(); + memcpy(result_data[ridx].GetDataWriteable() + result_lengths[ridx], sep_ptr, sep_size); + result_lengths[ridx] += sep_size; + } + auto input_ptr = input_data[idx].GetData(); + auto input_len = input_data[idx].GetSize(); + memcpy(result_data[ridx].GetDataWriteable() + result_lengths[ridx], input_ptr, input_len); + result_lengths[ridx] += input_len; + has_results[ridx] = true; + } + } + for (idx_t i = 0; i < count; i++) { + auto ridx = rsel.get_index(i); + result_data[ridx].Finalize(); + } +} + +static void ConcatWSFunction(DataChunk &args, ExpressionState &state, Vector &result) { + auto &separator = args.data[0]; + UnifiedVectorFormat vdata; + separator.ToUnifiedFormat(args.size(), vdata); + + result.SetVectorType(VectorType::CONSTANT_VECTOR); + for (idx_t col_idx = 0; col_idx < args.ColumnCount(); col_idx++) { + if (args.data[col_idx].GetVectorType() != VectorType::CONSTANT_VECTOR) { + result.SetVectorType(VectorType::FLAT_VECTOR); + break; + } + } + switch (separator.GetVectorType()) { + case VectorType::CONSTANT_VECTOR: { + if (ConstantVector::IsNull(separator)) { + // constant NULL as separator: return constant NULL vector + result.SetVectorType(VectorType::CONSTANT_VECTOR); + ConstantVector::SetNull(result, true); + return; + } + // no null values + auto sel = FlatVector::IncrementalSelectionVector(); + TemplatedConcatWS(args, UnifiedVectorFormat::GetData(vdata), *vdata.sel, *sel, args.size(), result); + return; + } + default: { + // default case: loop over nullmask and create a non-null selection vector + idx_t not_null_count = 0; + SelectionVector not_null_vector(STANDARD_VECTOR_SIZE); + auto &result_mask = FlatVector::Validity(result); + for (idx_t i = 0; i < args.size(); i++) { + if (!vdata.validity.RowIsValid(vdata.sel->get_index(i))) { + result_mask.SetInvalid(i); + } else { + not_null_vector.set_index(not_null_count++, i); + } + } + TemplatedConcatWS(args, UnifiedVectorFormat::GetData(vdata), *vdata.sel, not_null_vector, + not_null_count, result); + return; + } + } +} + +static unique_ptr BindConcatWSFunction(ClientContext &context, ScalarFunction &bound_function, + vector> &arguments) { + for (auto &arg : bound_function.arguments) { + arg = LogicalType::VARCHAR; + } + bound_function.varargs = LogicalType::VARCHAR; + return nullptr; +} + +void ConcatWSFun::RegisterFunction(BuiltinFunctions &set) { + // concat_ws functions similarly to the concat function, except the result is NULL if the separator is NULL + // if the separator is not NULL, however, NULL values are counted as empty string + // there is one separate rule: there are no separators added between NULL values, + // so the NULL value and empty string are different! + // e.g.: + // concat_ws(',', NULL, NULL) = "" + // concat_ws(',', '', '') = "," + + ScalarFunction concat_ws = ScalarFunction("concat_ws", {LogicalType::VARCHAR, LogicalType::ANY}, + LogicalType::VARCHAR, ConcatWSFunction, BindConcatWSFunction); + concat_ws.varargs = LogicalType::ANY; + concat_ws.null_handling = FunctionNullHandling::SPECIAL_HANDLING; + set.AddFunction(concat_ws); +} + +} // namespace duckdb diff --git a/src/function/scalar/string/substring.cpp b/src/function/scalar/string/substring.cpp index 76f4859f273..f7ff13f3499 100644 --- a/src/function/scalar/string/substring.cpp +++ b/src/function/scalar/string/substring.cpp @@ -224,11 +224,7 @@ string_t SubstringFun::SubstringGrapheme(Vector &result, string_t input, int64_t if (offset < 0) { // negative offset, this case is more difficult // we first need to count the number of characters in the string - idx_t num_characters = 0; - utf8proc_grapheme_callback(input_data, input_size, [&](size_t start, size_t end) { - num_characters++; - return true; - }); + idx_t num_characters = Utf8Proc::GraphemeCount(input_data, input_size); // now call substring start and end again, but with the number of unicode characters this time SubstringStartEnd(UnsafeNumericCast(num_characters), offset, length, start, end); } @@ -236,16 +232,15 @@ string_t SubstringFun::SubstringGrapheme(Vector &result, string_t input, int64_t // now scan the graphemes of the string to find the positions of the start and end characters int64_t current_character = 0; idx_t start_pos = DConstants::INVALID_INDEX, end_pos = input_size; - utf8proc_grapheme_callback(input_data, input_size, [&](size_t gstart, size_t gend) { + for (auto cluster : Utf8Proc::GraphemeClusters(input_data, input_size)) { if (current_character == start) { - start_pos = gstart; + start_pos = cluster.start; } else if (current_character == end) { - end_pos = gstart; - return false; + end_pos = cluster.start; + break; } current_character++; - return true; - }); + } if (start_pos == DConstants::INVALID_INDEX) { return SubstringEmptyString(result); } diff --git a/src/function/scalar/string_functions.cpp b/src/function/scalar/string_functions.cpp index 88d7b7169e3..e3ccbe0af9b 100644 --- a/src/function/scalar/string_functions.cpp +++ b/src/function/scalar/string_functions.cpp @@ -7,6 +7,7 @@ void BuiltinFunctions::RegisterStringFunctions() { Register(); Register(); Register(); + Register(); Register(); Register(); Register(); diff --git a/src/function/table/range.cpp b/src/function/table/range.cpp index ebc1f0bc204..17bcda81d3d 100644 --- a/src/function/table/range.cpp +++ b/src/function/table/range.cpp @@ -11,129 +11,196 @@ namespace duckdb { //===--------------------------------------------------------------------===// // Range (integers) //===--------------------------------------------------------------------===// +static void GetParameters(int64_t values[], idx_t value_count, hugeint_t &start, hugeint_t &end, hugeint_t &increment) { + if (value_count < 2) { + // single argument: only the end is specified + start = 0; + end = values[0]; + } else { + // two arguments: first two arguments are start and end + start = values[0]; + end = values[1]; + } + if (value_count < 3) { + increment = 1; + } else { + increment = values[2]; + } +} + struct RangeFunctionBindData : public TableFunctionData { + explicit RangeFunctionBindData(const vector &inputs) : cardinality(0) { + int64_t values[3]; + for (idx_t i = 0; i < inputs.size(); i++) { + if (inputs[i].IsNull()) { + return; + } + values[i] = inputs[i].GetValue(); + } + hugeint_t start; + hugeint_t end; + hugeint_t increment; + GetParameters(values, inputs.size(), start, end, increment); + cardinality = Hugeint::Cast((end - start) / increment); + } + + idx_t cardinality; +}; + +template +static unique_ptr RangeFunctionBind(ClientContext &context, TableFunctionBindInput &input, + vector &return_types, vector &names) { + return_types.emplace_back(LogicalType::BIGINT); + if (GENERATE_SERIES) { + names.emplace_back("generate_series"); + } else { + names.emplace_back("range"); + } + if (input.inputs.empty() || input.inputs.size() > 3) { + return nullptr; + } + return make_uniq(input.inputs); +} + +struct RangeFunctionLocalState : public LocalTableFunctionState { + RangeFunctionLocalState() { + } + + bool initialized_row = false; + idx_t current_input_row = 0; + idx_t current_idx = 0; + hugeint_t start; hugeint_t end; hugeint_t increment; - -public: - bool Equals(const FunctionData &other_p) const override { - auto &other = other_p.Cast(); - return other.start == start && other.end == end && other.increment == increment; - } }; +static unique_ptr RangeFunctionLocalInit(ExecutionContext &context, + TableFunctionInitInput &input, + GlobalTableFunctionState *global_state) { + return make_uniq(); +} + template -static void GenerateRangeParameters(const vector &inputs, RangeFunctionBindData &result) { - for (auto &input : inputs) { - if (input.IsNull()) { +static void GenerateRangeParameters(DataChunk &input, idx_t row_id, RangeFunctionLocalState &result) { + input.Flatten(); + for (idx_t c = 0; c < input.ColumnCount(); c++) { + if (FlatVector::IsNull(input.data[c], row_id)) { result.start = GENERATE_SERIES ? 1 : 0; result.end = 0; result.increment = 1; return; } } - if (inputs.size() < 2) { - // single argument: only the end is specified - result.start = 0; - result.end = inputs[0].GetValue(); - } else { - // two arguments: first two arguments are start and end - result.start = inputs[0].GetValue(); - result.end = inputs[1].GetValue(); - } - if (inputs.size() < 3) { - result.increment = 1; - } else { - result.increment = inputs[2].GetValue(); + int64_t values[3]; + for (idx_t c = 0; c < input.ColumnCount(); c++) { + if (c >= 3) { + throw InternalException("Unsupported parameter count for range function"); + } + values[c] = FlatVector::GetValue(input.data[c], row_id); } + GetParameters(values, input.ColumnCount(), result.start, result.end, result.increment); if (result.increment == 0) { throw BinderException("interval cannot be 0!"); } if (result.start > result.end && result.increment > 0) { throw BinderException("start is bigger than end, but increment is positive: cannot generate infinite series"); - } else if (result.start < result.end && result.increment < 0) { + } + if (result.start < result.end && result.increment < 0) { throw BinderException("start is smaller than end, but increment is negative: cannot generate infinite series"); } -} - -template -static unique_ptr RangeFunctionBind(ClientContext &context, TableFunctionBindInput &input, - vector &return_types, vector &names) { - auto result = make_uniq(); - auto &inputs = input.inputs; - GenerateRangeParameters(inputs, *result); - - return_types.emplace_back(LogicalType::BIGINT); if (GENERATE_SERIES) { // generate_series has inclusive bounds on the RHS - if (result->increment < 0) { - result->end = result->end - 1; + if (result.increment < 0) { + result.end = result.end - 1; } else { - result->end = result->end + 1; + result.end = result.end + 1; } - names.emplace_back("generate_series"); - } else { - names.emplace_back("range"); } - return std::move(result); } -struct RangeFunctionState : public GlobalTableFunctionState { - RangeFunctionState() : current_idx(0) { - } - - int64_t current_idx; -}; - -static unique_ptr RangeFunctionInit(ClientContext &context, TableFunctionInitInput &input) { - return make_uniq(); -} - -static void RangeFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) { - auto &bind_data = data_p.bind_data->Cast(); - auto &state = data_p.global_state->Cast(); - - auto increment = bind_data.increment; - auto end = bind_data.end; - hugeint_t current_value = bind_data.start + increment * state.current_idx; - int64_t current_value_i64; - if (!Hugeint::TryCast(current_value, current_value_i64)) { - return; +template +static OperatorResultType RangeFunction(ExecutionContext &context, TableFunctionInput &data_p, DataChunk &input, + DataChunk &output) { + auto &state = data_p.local_state->Cast(); + while (true) { + if (!state.initialized_row) { + // initialize for the current input row + if (state.current_input_row >= input.size()) { + // ran out of rows + state.current_input_row = 0; + state.initialized_row = false; + return OperatorResultType::NEED_MORE_INPUT; + } + GenerateRangeParameters(input, state.current_input_row, state); + state.initialized_row = true; + state.current_idx = 0; + } + auto increment = state.increment; + auto end = state.end; + hugeint_t current_value = state.start + increment * UnsafeNumericCast(state.current_idx); + int64_t current_value_i64; + if (!Hugeint::TryCast(current_value, current_value_i64)) { + // move to next row + state.current_input_row++; + state.initialized_row = false; + continue; + } + int64_t offset = increment < 0 ? 1 : -1; + idx_t remaining = MinValue( + Hugeint::Cast((end - current_value + (increment + offset)) / increment), STANDARD_VECTOR_SIZE); + // set the result vector as a sequence vector + output.data[0].Sequence(current_value_i64, Hugeint::Cast(increment), remaining); + // increment the index pointer by the remaining count + state.current_idx += remaining; + output.SetCardinality(remaining); + if (remaining == 0) { + // move to next row + state.current_input_row++; + state.initialized_row = false; + continue; + } + return OperatorResultType::HAVE_MORE_OUTPUT; } - int64_t offset = increment < 0 ? 1 : -1; - idx_t remaining = MinValue(Hugeint::Cast((end - current_value + (increment + offset)) / increment), - STANDARD_VECTOR_SIZE); - // set the result vector as a sequence vector - output.data[0].Sequence(current_value_i64, Hugeint::Cast(increment), remaining); - // increment the index pointer by the remaining count - state.current_idx += remaining; - output.SetCardinality(remaining); } unique_ptr RangeCardinality(ClientContext &context, const FunctionData *bind_data_p) { + if (!bind_data_p) { + return nullptr; + } auto &bind_data = bind_data_p->Cast(); - idx_t cardinality = Hugeint::Cast((bind_data.end - bind_data.start) / bind_data.increment); - return make_uniq(cardinality, cardinality); + return make_uniq(bind_data.cardinality, bind_data.cardinality); } //===--------------------------------------------------------------------===// // Range (timestamp) //===--------------------------------------------------------------------===// -struct RangeDateTimeBindData : public TableFunctionData { +template +static unique_ptr RangeDateTimeBind(ClientContext &context, TableFunctionBindInput &input, + vector &return_types, vector &names) { + return_types.push_back(LogicalType::TIMESTAMP); + if (GENERATE_SERIES) { + names.emplace_back("generate_series"); + } else { + names.emplace_back("range"); + } + return nullptr; +} + +struct RangeDateTimeLocalState : public LocalTableFunctionState { + RangeDateTimeLocalState() { + } + + bool initialized_row = false; + idx_t current_input_row = 0; + timestamp_t current_state; + timestamp_t start; timestamp_t end; interval_t increment; bool inclusive_bound; bool greater_than_check; -public: - bool Equals(const FunctionData &other_p) const override { - auto &other = other_p.Cast(); - return other.start == start && other.end == end && other.increment == increment && - other.inclusive_bound == inclusive_bound && other.greater_than_check == greater_than_check; - } - bool Finished(timestamp_t current_value) const { if (greater_than_check) { if (inclusive_bound) { @@ -152,98 +219,105 @@ struct RangeDateTimeBindData : public TableFunctionData { }; template -static unique_ptr RangeDateTimeBind(ClientContext &context, TableFunctionBindInput &input, - vector &return_types, vector &names) { - 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"); +static void GenerateRangeDateTimeParameters(DataChunk &input, idx_t row_id, RangeDateTimeLocalState &result) { + input.Flatten(); + + for (idx_t c = 0; c < input.ColumnCount(); c++) { + if (FlatVector::IsNull(input.data[c], row_id)) { + result.start = timestamp_t(0); + result.end = timestamp_t(0); + result.increment = interval_t(); + result.greater_than_check = true; + result.inclusive_bound = false; + return; } } - result->start = inputs[0].GetValue(); - result->end = inputs[1].GetValue(); - result->increment = inputs[2].GetValue(); + + result.start = FlatVector::GetValue(input.data[0], row_id); + result.end = FlatVector::GetValue(input.data[1], row_id); + result.increment = FlatVector::GetValue(input.data[2], row_id); // Infinities either cause errors or infinite loops, so just ban them - if (!Timestamp::IsFinite(result->start) || !Timestamp::IsFinite(result->end)) { + if (!Timestamp::IsFinite(result.start) || !Timestamp::IsFinite(result.end)) { throw BinderException("RANGE with infinite bounds is not supported"); } - if (result->increment.months == 0 && result->increment.days == 0 && result->increment.micros == 0) { + if (result.increment.months == 0 && result.increment.days == 0 && result.increment.micros == 0) { throw BinderException("interval cannot be 0!"); } // all elements should point in the same direction - if (result->increment.months > 0 || result->increment.days > 0 || result->increment.micros > 0) { - if (result->increment.months < 0 || result->increment.days < 0 || result->increment.micros < 0) { + if (result.increment.months > 0 || result.increment.days > 0 || result.increment.micros > 0) { + if (result.increment.months < 0 || result.increment.days < 0 || result.increment.micros < 0) { throw BinderException("RANGE with composite interval that has mixed signs is not supported"); } - result->greater_than_check = true; - if (result->start > result->end) { + result.greater_than_check = true; + if (result.start > result.end) { throw BinderException( "start is bigger than end, but increment is positive: cannot generate infinite series"); } } else { - result->greater_than_check = false; - if (result->start < result->end) { + result.greater_than_check = false; + if (result.start < result.end) { throw BinderException( "start is smaller than end, but increment is negative: cannot generate infinite series"); } } - return_types.push_back(inputs[0].type()); - if (GENERATE_SERIES) { - // generate_series has inclusive bounds on the RHS - result->inclusive_bound = true; - names.emplace_back("generate_series"); - } else { - result->inclusive_bound = false; - names.emplace_back("range"); - } - return std::move(result); + result.inclusive_bound = GENERATE_SERIES; } -struct RangeDateTimeState : public GlobalTableFunctionState { - explicit RangeDateTimeState(timestamp_t start_p) : current_state(start_p) { - } - - timestamp_t current_state; - bool finished = false; -}; - -static unique_ptr RangeDateTimeInit(ClientContext &context, TableFunctionInitInput &input) { - auto &bind_data = input.bind_data->Cast(); - return make_uniq(bind_data.start); +static unique_ptr RangeDateTimeLocalInit(ExecutionContext &context, + TableFunctionInitInput &input, + GlobalTableFunctionState *global_state) { + return make_uniq(); } -static void RangeDateTimeFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) { - auto &bind_data = data_p.bind_data->Cast(); - auto &state = data_p.global_state->Cast(); - if (state.finished) { - return; - } - - idx_t size = 0; - auto data = FlatVector::GetData(output.data[0]); +template +static OperatorResultType RangeDateTimeFunction(ExecutionContext &context, TableFunctionInput &data_p, DataChunk &input, + DataChunk &output) { + auto &state = data_p.local_state->Cast(); while (true) { - if (bind_data.Finished(state.current_state)) { - state.finished = true; - break; + if (!state.initialized_row) { + // initialize for the current input row + if (state.current_input_row >= input.size()) { + // ran out of rows + state.current_input_row = 0; + state.initialized_row = false; + return OperatorResultType::NEED_MORE_INPUT; + } + GenerateRangeDateTimeParameters(input, state.current_input_row, state); + state.initialized_row = true; + state.current_state = state.start; + } + idx_t size = 0; + auto data = FlatVector::GetData(output.data[0]); + while (true) { + if (state.Finished(state.current_state)) { + break; + } + if (size >= STANDARD_VECTOR_SIZE) { + break; + } + data[size++] = state.current_state; + state.current_state = + AddOperator::Operation(state.current_state, state.increment); } - if (size >= STANDARD_VECTOR_SIZE) { - break; + if (size == 0) { + // move to next row + state.current_input_row++; + state.initialized_row = false; + continue; } - data[size++] = state.current_state; - state.current_state = - AddOperator::Operation(state.current_state, bind_data.increment); + output.SetCardinality(size); + return OperatorResultType::HAVE_MORE_OUTPUT; } - output.SetCardinality(size); } void RangeTableFunction::RegisterFunction(BuiltinFunctions &set) { TableFunctionSet range("range"); - TableFunction range_function({LogicalType::BIGINT}, RangeFunction, RangeFunctionBind, RangeFunctionInit); + TableFunction range_function({LogicalType::BIGINT}, nullptr, RangeFunctionBind, nullptr, + RangeFunctionLocalInit); + range_function.in_out_function = RangeFunction; range_function.cardinality = RangeCardinality; // single argument range: (end) - implicit start = 0 and increment = 1 @@ -254,20 +328,25 @@ void RangeTableFunction::RegisterFunction(BuiltinFunctions &set) { // three arguments range: (start, end, increment) range_function.arguments = {LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT}; range.AddFunction(range_function); - range.AddFunction(TableFunction({LogicalType::TIMESTAMP, LogicalType::TIMESTAMP, LogicalType::INTERVAL}, - RangeDateTimeFunction, RangeDateTimeBind, RangeDateTimeInit)); + TableFunction range_in_out({LogicalType::TIMESTAMP, LogicalType::TIMESTAMP, LogicalType::INTERVAL}, nullptr, + RangeDateTimeBind, nullptr, RangeDateTimeLocalInit); + range_in_out.in_out_function = RangeDateTimeFunction; + range.AddFunction(range_in_out); set.AddFunction(range); // generate_series: similar to range, but inclusive instead of exclusive bounds on the RHS TableFunctionSet generate_series("generate_series"); range_function.bind = RangeFunctionBind; + range_function.in_out_function = RangeFunction; range_function.arguments = {LogicalType::BIGINT}; generate_series.AddFunction(range_function); range_function.arguments = {LogicalType::BIGINT, LogicalType::BIGINT}; generate_series.AddFunction(range_function); range_function.arguments = {LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT}; generate_series.AddFunction(range_function); - generate_series.AddFunction(TableFunction({LogicalType::TIMESTAMP, LogicalType::TIMESTAMP, LogicalType::INTERVAL}, - RangeDateTimeFunction, RangeDateTimeBind, RangeDateTimeInit)); + TableFunction generate_series_in_out({LogicalType::TIMESTAMP, LogicalType::TIMESTAMP, LogicalType::INTERVAL}, + nullptr, RangeDateTimeBind, nullptr, RangeDateTimeLocalInit); + generate_series_in_out.in_out_function = RangeDateTimeFunction; + generate_series.AddFunction(generate_series_in_out); set.AddFunction(generate_series); } diff --git a/src/function/table/read_csv.cpp b/src/function/table/read_csv.cpp index 58cbfdd764d..59091c0c581 100644 --- a/src/function/table/read_csv.cpp +++ b/src/function/table/read_csv.cpp @@ -202,6 +202,10 @@ unique_ptr ReadCSVInitLocal(ExecutionContext &context, return nullptr; } auto &global_state = global_state_p->Cast(); + if (global_state.current_boundary.done) { + // nothing to do + return nullptr; + } auto csv_scanner = global_state.Next(nullptr); if (!csv_scanner) { global_state.DecrementThread(); @@ -215,6 +219,9 @@ static void ReadCSVFunction(ClientContext &context, TableFunctionInput &data_p, return; } auto &csv_global_state = data_p.global_state->Cast(); + if (!data_p.local_state) { + return; + } auto &csv_local_state = data_p.local_state->Cast(); if (!csv_local_state.csv_reader) { diff --git a/src/function/table/unnest.cpp b/src/function/table/unnest.cpp index b6485bc3d2a..b7599270f1c 100644 --- a/src/function/table/unnest.cpp +++ b/src/function/table/unnest.cpp @@ -47,7 +47,7 @@ static unique_ptr UnnestBind(ClientContext &context, TableFunction throw BinderException("UNNEST requires a single list as input"); } return_types.push_back(ListType::GetChildType(input.input_table_types[0])); - names.push_back(input.input_table_names[0]); + names.push_back("unnest"); return make_uniq(input.input_table_types[0]); } @@ -78,7 +78,8 @@ static OperatorResultType UnnestFunction(ExecutionContext &context, TableFunctio } void UnnestTableFunction::RegisterFunction(BuiltinFunctions &set) { - TableFunction unnest_function("unnest", {LogicalTypeId::TABLE}, nullptr, UnnestBind, UnnestInit, UnnestLocalInit); + TableFunction unnest_function("unnest", {LogicalType::LIST(LogicalType::ANY)}, nullptr, UnnestBind, UnnestInit, + UnnestLocalInit); unnest_function.in_out_function = UnnestFunction; set.AddFunction(unnest_function); } diff --git a/src/include/duckdb.h b/src/include/duckdb.h index 8a8a752ef5c..c6bd9d93c8f 100644 --- a/src/include/duckdb.h +++ b/src/include/duckdb.h @@ -1733,7 +1733,7 @@ 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` +Creates an 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 @@ -1793,7 +1793,7 @@ 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. +Creates an 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. @@ -2805,6 +2805,11 @@ Finish the current row of appends. After end_row is called, the next row can be */ DUCKDB_API duckdb_state duckdb_appender_end_row(duckdb_appender appender); +/*! +Append a DEFAULT value (NULL if DEFAULT not available for column) to the appender. +*/ +DUCKDB_API duckdb_state duckdb_append_default(duckdb_appender appender); + /*! Append a bool value to the appender. */ diff --git a/src/include/duckdb/common/arrow/arrow_buffer.hpp b/src/include/duckdb/common/arrow/arrow_buffer.hpp index e1624ef64da..66dd863f7e6 100644 --- a/src/include/duckdb/common/arrow/arrow_buffer.hpp +++ b/src/include/duckdb/common/arrow/arrow_buffer.hpp @@ -32,7 +32,7 @@ struct ArrowBuffer { ArrowBuffer(const ArrowBuffer &other) = delete; ArrowBuffer &operator=(const ArrowBuffer &) = delete; //! enable move constructors - ArrowBuffer(ArrowBuffer &&other) noexcept { + ArrowBuffer(ArrowBuffer &&other) noexcept : count(0), capacity(0) { std::swap(dataptr, other.dataptr); std::swap(count, other.count); std::swap(capacity, other.capacity); diff --git a/src/include/duckdb/common/enum_util.hpp b/src/include/duckdb/common/enum_util.hpp index 021b27088f5..71c5a34d34f 100644 --- a/src/include/duckdb/common/enum_util.hpp +++ b/src/include/duckdb/common/enum_util.hpp @@ -100,6 +100,8 @@ enum class ConflictManagerMode : uint8_t; enum class ConstraintType : uint8_t; +enum class CopyFunctionReturnType : uint8_t; + enum class CopyOverwriteMode : uint8_t; enum class DataFileType : uint8_t; @@ -314,6 +316,8 @@ enum class TaskExecutionResult : uint8_t; enum class TimestampCastResult : uint8_t; +enum class TransactionModifierType : uint8_t; + enum class TransactionType : uint8_t; enum class TupleDataPinProperties : uint8_t; @@ -443,6 +447,9 @@ const char* EnumUtil::ToChars(ConflictManagerMode value); template<> const char* EnumUtil::ToChars(ConstraintType value); +template<> +const char* EnumUtil::ToChars(CopyFunctionReturnType value); + template<> const char* EnumUtil::ToChars(CopyOverwriteMode value); @@ -764,6 +771,9 @@ const char* EnumUtil::ToChars(TaskExecutionResult value); template<> const char* EnumUtil::ToChars(TimestampCastResult value); +template<> +const char* EnumUtil::ToChars(TransactionModifierType value); + template<> const char* EnumUtil::ToChars(TransactionType value); @@ -906,6 +916,9 @@ ConflictManagerMode EnumUtil::FromString(const char *value) template<> ConstraintType EnumUtil::FromString(const char *value); +template<> +CopyFunctionReturnType EnumUtil::FromString(const char *value); + template<> CopyOverwriteMode EnumUtil::FromString(const char *value); @@ -1227,6 +1240,9 @@ TaskExecutionResult EnumUtil::FromString(const char *value) template<> TimestampCastResult EnumUtil::FromString(const char *value); +template<> +TransactionModifierType EnumUtil::FromString(const char *value); + template<> TransactionType EnumUtil::FromString(const char *value); diff --git a/src/include/duckdb/common/enums/copy_overwrite_mode.hpp b/src/include/duckdb/common/enums/copy_overwrite_mode.hpp index 595a867e9a3..89644f8993e 100644 --- a/src/include/duckdb/common/enums/copy_overwrite_mode.hpp +++ b/src/include/duckdb/common/enums/copy_overwrite_mode.hpp @@ -13,6 +13,11 @@ namespace duckdb { -enum class CopyOverwriteMode : uint8_t { COPY_ERROR_ON_CONFLICT = 0, COPY_OVERWRITE = 1, COPY_OVERWRITE_OR_IGNORE = 2 }; +enum class CopyOverwriteMode : uint8_t { + COPY_ERROR_ON_CONFLICT = 0, + COPY_OVERWRITE = 1, + COPY_OVERWRITE_OR_IGNORE = 2, + COPY_APPEND = 3 +}; } // namespace duckdb diff --git a/src/include/duckdb/common/enums/join_type.hpp b/src/include/duckdb/common/enums/join_type.hpp index 4b3446963ea..8ba8e27295f 100644 --- a/src/include/duckdb/common/enums/join_type.hpp +++ b/src/include/duckdb/common/enums/join_type.hpp @@ -29,8 +29,8 @@ enum class JoinType : uint8_t { // (and NULL if no partner is found) RIGHT_SEMI = 9, // RIGHT SEMI join is created by the optimizer when the children of a semi join need to be switched // so that the build side can be the smaller table - RIGHT_ANTI = 10 // RIGHT ANTI join is created by the optimizer when the children of an anti join need to be switched - // so that the build side can be the smaller table + RIGHT_ANTI = 10 // RIGHT ANTI join is created by the optimizer when the children of an anti join need to be + // switched so that the build side can be the smaller table }; //! True if join is left or full outer join diff --git a/src/include/duckdb/common/file_system.hpp b/src/include/duckdb/common/file_system.hpp index e0df2f70c26..fa2b9381999 100644 --- a/src/include/duckdb/common/file_system.hpp +++ b/src/include/duckdb/common/file_system.hpp @@ -238,6 +238,7 @@ class FileSystem { //! Whether or not a file is remote or local, based only on file path DUCKDB_API static bool IsRemoteFile(const string &path); + DUCKDB_API static bool IsRemoteFile(const string &path, string &extension); DUCKDB_API virtual void SetDisabledFileSystems(const vector &names); diff --git a/src/include/duckdb/common/filename_pattern.hpp b/src/include/duckdb/common/filename_pattern.hpp index 311fa602d99..4ec3827f581 100644 --- a/src/include/duckdb/common/filename_pattern.hpp +++ b/src/include/duckdb/common/filename_pattern.hpp @@ -30,6 +30,10 @@ class FilenamePattern { void Serialize(Serializer &serializer) const; static FilenamePattern Deserialize(Deserializer &deserializer); + bool HasUUID() const { + return uuid; + } + private: string base; idx_t pos; diff --git a/src/include/duckdb/common/hive_partitioning.hpp b/src/include/duckdb/common/hive_partitioning.hpp index 9ba4c82a2ff..3bf59313da2 100644 --- a/src/include/duckdb/common/hive_partitioning.hpp +++ b/src/include/duckdb/common/hive_partitioning.hpp @@ -14,11 +14,14 @@ #include "duckdb/optimizer/statistics_propagator.hpp" #include "duckdb/planner/expression_iterator.hpp" #include "duckdb/planner/table_filter.hpp" -#include "re2/re2.h" #include #include +namespace duckdb_re2 { +class RE2; +} // namespace duckdb_re2 + namespace duckdb { class HivePartitioning { diff --git a/src/include/duckdb/common/row_operations/row_matcher.hpp b/src/include/duckdb/common/row_operations/row_matcher.hpp index 006e2f6dcb2..2b419b2f7af 100644 --- a/src/include/duckdb/common/row_operations/row_matcher.hpp +++ b/src/include/duckdb/common/row_operations/row_matcher.hpp @@ -36,6 +36,12 @@ struct RowMatcher { //! Initializes the RowMatcher, filling match_functions using layout and predicates void Initialize(const bool no_match_sel, const TupleDataLayout &layout, const Predicates &predicates); + + //! Initializes the RowMatcher, filling match_functions using layout and equality_predicates but only for the given + //! columns + void Initialize(const bool no_match_sel, const TupleDataLayout &layout, const Predicates &predicates, + vector &columns); + //! Given a DataChunk on the LHS, on which we've called TupleDataCollection::ToUnifiedFormat, //! we match it with rows on the RHS, according to the given layout and locations. //! Initially, 'sel' has 'count' entries which point to what needs to be compared. @@ -44,6 +50,12 @@ struct RowMatcher { const TupleDataLayout &rhs_layout, Vector &rhs_row_locations, SelectionVector *no_match_sel, idx_t &no_match_count); + //! Same as Match above, but only compares the column indexes in columns. Needs to be initialized with the same + //! columns. + idx_t Match(DataChunk &lhs, const vector &lhs_formats, SelectionVector &sel, idx_t count, + const TupleDataLayout &rhs_layout, Vector &rhs_row_locations, SelectionVector *no_match_sel, + idx_t &no_match_count, const vector &columns); + private: //! Gets the templated match function for a given column MatchFunction GetMatchFunction(const bool no_match_sel, const LogicalType &type, const ExpressionType predicate); diff --git a/src/include/duckdb/common/serializer/buffered_file_writer.hpp b/src/include/duckdb/common/serializer/buffered_file_writer.hpp index 26f0460c437..92095379ff4 100644 --- a/src/include/duckdb/common/serializer/buffered_file_writer.hpp +++ b/src/include/duckdb/common/serializer/buffered_file_writer.hpp @@ -32,7 +32,9 @@ class BufferedFileWriter : public WriteStream { public: DUCKDB_API void WriteData(const_data_ptr_t buffer, idx_t write_size) override; - //! Flush the buffer to disk and sync the file to ensure writing is completed + //! Flush all changes to the file and then close the file + DUCKDB_API void Close(); + //! Flush all changes and fsync the file to disk DUCKDB_API void Sync(); //! Flush the buffer to the file (without sync) DUCKDB_API void Flush(); diff --git a/src/include/duckdb/common/types/row/tuple_data_collection.hpp b/src/include/duckdb/common/types/row/tuple_data_collection.hpp index 01fc20ec33d..1612287d570 100644 --- a/src/include/duckdb/common/types/row/tuple_data_collection.hpp +++ b/src/include/duckdb/common/types/row/tuple_data_collection.hpp @@ -145,6 +145,8 @@ class TupleDataCollection { //! Initializes a chunk with the correct types that can be used to call Append/Scan void InitializeChunk(DataChunk &chunk) const; + //! Initializes a chunk with the correct types that can be used to call Append/Scan for the given columns + void InitializeChunk(DataChunk &chunk, const vector &columns) const; //! Initializes a chunk with the correct types for a given scan state void InitializeScanChunk(TupleDataScanState &state, DataChunk &chunk) const; //! Initializes a Scan state for scanning all columns diff --git a/src/include/duckdb/common/types/selection_vector.hpp b/src/include/duckdb/common/types/selection_vector.hpp index 969c785690d..92bf9e135ac 100644 --- a/src/include/duckdb/common/types/selection_vector.hpp +++ b/src/include/duckdb/common/types/selection_vector.hpp @@ -111,6 +111,7 @@ struct SelectionVector { inline sel_t &operator[](idx_t index) const { return sel_vector[index]; } + void Verify(idx_t count, idx_t vector_size) const; private: sel_t *sel_vector; diff --git a/src/include/duckdb/core_functions/aggregate/distributive_functions.hpp b/src/include/duckdb/core_functions/aggregate/distributive_functions.hpp index 3f65ca2666f..dc2ecae9b66 100644 --- a/src/include/duckdb/core_functions/aggregate/distributive_functions.hpp +++ b/src/include/duckdb/core_functions/aggregate/distributive_functions.hpp @@ -17,11 +17,11 @@ namespace duckdb { struct ApproxCountDistinctFun { static constexpr const char *Name = "approx_count_distinct"; - static constexpr const char *Parameters = "x"; + static constexpr const char *Parameters = "any"; static constexpr const char *Description = "Computes the approximate count of distinct elements using HyperLogLog."; static constexpr const char *Example = "approx_count_distinct(A)"; - static AggregateFunctionSet GetFunctions(); + static AggregateFunction GetFunction(); }; struct ArgMinFun { diff --git a/src/include/duckdb/execution/aggregate_hashtable.hpp b/src/include/duckdb/execution/aggregate_hashtable.hpp index 797e96ca949..2b424152f2c 100644 --- a/src/include/duckdb/execution/aggregate_hashtable.hpp +++ b/src/include/duckdb/execution/aggregate_hashtable.hpp @@ -11,6 +11,7 @@ #include "duckdb/common/row_operations/row_matcher.hpp" #include "duckdb/common/types/row/partitioned_tuple_data.hpp" #include "duckdb/execution/base_aggregate_hashtable.hpp" +#include "duckdb/execution/ht_entry.hpp" #include "duckdb/storage/arena_allocator.hpp" #include "duckdb/storage/buffer/buffer_handle.hpp" @@ -29,53 +30,6 @@ struct FlushMoveState; stores them in the HT. It uses linear probing for collision resolution. */ -struct aggr_ht_entry_t { // NOLINT -public: - explicit aggr_ht_entry_t(hash_t value_p) : value(value_p) { - } - - inline bool IsOccupied() const { - return value != 0; - } - - inline data_ptr_t GetPointer() const { - D_ASSERT(IsOccupied()); - return reinterpret_cast(value & POINTER_MASK); - } - inline void SetPointer(const data_ptr_t &pointer) { - // Pointer shouldn't use upper bits - D_ASSERT((reinterpret_cast(pointer) & SALT_MASK) == 0); - // Value should have all 1's in the pointer area - D_ASSERT((value & POINTER_MASK) == POINTER_MASK); - // Set upper bits to 1 in pointer so the salt stays intact - value &= reinterpret_cast(pointer) | SALT_MASK; - } - - static inline hash_t ExtractSalt(const hash_t &hash) { - // Leaves upper bits intact, sets lower bits to all 1's - return hash | POINTER_MASK; - } - inline hash_t GetSalt() const { - return ExtractSalt(value); - } - inline void SetSalt(const hash_t &salt) { - // Shouldn't be occupied when we set this - D_ASSERT(!IsOccupied()); - // Salt should have all 1's in the pointer field - D_ASSERT((salt & POINTER_MASK) == POINTER_MASK); - // No need to mask, just put the whole thing there - value = salt; - } - -private: - //! Upper 16 bits are salt - static constexpr const hash_t SALT_MASK = 0xFFFF000000000000; - //! Lower 48 bits are the pointer - static constexpr const hash_t POINTER_MASK = 0x0000FFFFFFFFFFFF; - - hash_t value; -}; - class GroupedAggregateHashTable : public BaseAggregateHashTable { public: GroupedAggregateHashTable(ClientContext &context, Allocator &allocator, vector group_types, @@ -178,7 +132,7 @@ class GroupedAggregateHashTable : public BaseAggregateHashTable { idx_t capacity; //! The hash map (pointer table) of the HT: allocated data and pointer into it AllocatedData hash_map; - aggr_ht_entry_t *entries; + ht_entry_t *entries; //! Offset of the hash column in the rows idx_t hash_offset; //! Bitmask for getting relevant bits from the hashes to determine the position diff --git a/src/include/duckdb/execution/ht_entry.hpp b/src/include/duckdb/execution/ht_entry.hpp new file mode 100644 index 00000000000..43483eaf682 --- /dev/null +++ b/src/include/duckdb/execution/ht_entry.hpp @@ -0,0 +1,94 @@ +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/execution/ht_entry.hpp +// +// +//===----------------------------------------------------------------------===// + +#pragma once + +namespace duckdb { + +//! The ht_entry_t struct represents an individual entry within a hash table. +/*! + This struct is used by the JoinHashTable and AggregateHashTable to store entries within the hash table. It stores + a pointer to the data and a salt value in a single hash_t and can return or modify the pointer and salt + individually. +*/ +struct ht_entry_t { // NOLINT +public: + //! Upper 16 bits are salt + static constexpr const duckdb::hash_t SALT_MASK = 0xFFFF000000000000; + //! Lower 48 bits are the pointer + static constexpr const duckdb::hash_t POINTER_MASK = 0x0000FFFFFFFFFFFF; + + explicit inline ht_entry_t(duckdb::hash_t value_p) : value(value_p) { + } + + // Add a default constructor for 32-bit linux test case + ht_entry_t() : value(0) { + } + + inline bool IsOccupied() const { + return value != 0; + } + + // Returns a pointer based on the stored value without checking cell occupancy. + // This can return a nullptr if the cell is not occupied. + inline duckdb::data_ptr_t GetPointerOrNull() const { + return reinterpret_cast(value & POINTER_MASK); + } + + // Returns a pointer based on the stored value if the cell is occupied + inline duckdb::data_ptr_t GetPointer() const { + D_ASSERT(IsOccupied()); + return reinterpret_cast(value & POINTER_MASK); + } + + inline void SetPointer(const duckdb::data_ptr_t &pointer) { + // Pointer shouldn't use upper bits + D_ASSERT((reinterpret_cast(pointer) & SALT_MASK) == 0); + // Value should have all 1's in the pointer area + D_ASSERT((value & POINTER_MASK) == POINTER_MASK); + // Set upper bits to 1 in pointer so the salt stays intact + value &= reinterpret_cast(pointer) | SALT_MASK; + } + + // Returns the salt, leaves upper salt bits intact, sets lower bits to all 1's + static inline duckdb::hash_t ExtractSalt(const duckdb::hash_t &hash) { + return hash | POINTER_MASK; + } + + // Returns the salt, leaves upper salt bits intact, sets lower bits to all 0's + static inline duckdb::hash_t ExtractSaltWithNulls(const duckdb::hash_t &hash) { + return hash & SALT_MASK; + } + + inline duckdb::hash_t GetSalt() const { + return ExtractSalt(value); + } + + inline void SetSalt(const duckdb::hash_t &salt) { + // Shouldn't be occupied when we set this + D_ASSERT(!IsOccupied()); + // Salt should have all 1's in the pointer field + D_ASSERT((salt & POINTER_MASK) == POINTER_MASK); + // No need to mask, just put the whole thing there + value = salt; + } + + static inline ht_entry_t GetDesiredEntry(const duckdb::data_ptr_t &pointer, const duckdb::hash_t &salt) { + auto desired = reinterpret_cast(pointer) | (salt & SALT_MASK); + return ht_entry_t(desired); + } + + static inline ht_entry_t GetEmptyEntry() { + return ht_entry_t(0); + } + +private: + duckdb::hash_t value; +}; + +} // namespace duckdb diff --git a/src/include/duckdb/execution/index/art/art.hpp b/src/include/duckdb/execution/index/art/art.hpp index 07a0318040f..041e514aaa9 100644 --- a/src/include/duckdb/execution/index/art/art.hpp +++ b/src/include/duckdb/execution/index/art/art.hpp @@ -81,15 +81,13 @@ class ART : public BoundIndex { //! Delete a chunk of entries from the index. The lock obtained from InitializeLock must be held void Delete(IndexLock &lock, DataChunk &entries, Vector &row_identifiers) override; //! Insert a chunk of entries into the index - ErrorData Insert(IndexLock &lock, DataChunk &data, Vector &row_ids) override; + ErrorData Insert(IndexLock &lock, DataChunk &data, Vector &row_identifiers) override; //! Construct an ART from a vector of sorted keys bool ConstructFromSorted(idx_t count, vector &keys, Vector &row_identifiers); //! Search equal values and fetches the row IDs bool SearchEqual(ARTKey &key, idx_t max_count, vector &result_ids); - //! Search equal values used for joins that do not need to fetch data - void SearchEqualJoinNoFetch(ARTKey &key, idx_t &result_size); //! Returns all ART storage information for serialization IndexStorageInfo GetStorageInfo(const bool get_buffers) override; @@ -105,6 +103,7 @@ class ART : public BoundIndex { idx_t GetInMemorySize(IndexLock &index_lock) override; //! Generate ART keys for an input chunk + template static void GenerateKeys(ArenaAllocator &allocator, DataChunk &input, vector &keys); //! Generate a string containing all the expressions and their respective values that violate a constraint @@ -163,4 +162,10 @@ class ART : public BoundIndex { DataChunk &input) override; }; +template <> +void ART::GenerateKeys<>(ArenaAllocator &allocator, DataChunk &input, vector &keys); + +template <> +void ART::GenerateKeys(ArenaAllocator &allocator, DataChunk &input, vector &keys); + } // namespace duckdb diff --git a/src/include/duckdb/execution/join_hashtable.hpp b/src/include/duckdb/execution/join_hashtable.hpp index b4910a55422..b5af73a8a77 100644 --- a/src/include/duckdb/execution/join_hashtable.hpp +++ b/src/include/duckdb/execution/join_hashtable.hpp @@ -17,6 +17,7 @@ #include "duckdb/common/types/row/tuple_data_layout.hpp" #include "duckdb/common/types/vector.hpp" #include "duckdb/execution/aggregate_hashtable.hpp" +#include "duckdb/execution/ht_entry.hpp" #include "duckdb/planner/operator/logical_comparison_join.hpp" #include "duckdb/storage/storage_info.hpp" @@ -60,15 +61,23 @@ class JoinHashTable { public: using ValidityBytes = TemplatedValidityMask; + // only compare salts with the ht entries if the capacity is larger than 8192 so + // that it does not fit into the CPU cache + static constexpr const idx_t USE_SALT_THRESHOLD = 8192; + //! Scan structure that can be used to resume scans, as a single probe can //! return 1024*N values (where N is the size of the HT). This is //! returned by the JoinHashTable::Scan function and can be used to resume a //! probe. struct ScanStructure { TupleDataChunkState &key_state; + //! Directly point to the entry in the hash table Vector pointers; idx_t count; SelectionVector sel_vector; + SelectionVector chain_match_sel_vector; + SelectionVector chain_no_match_sel_vector; + // whether or not the given tuple has found a match unsafe_unique_array found_match; JoinHashTable &ht; @@ -78,7 +87,7 @@ class JoinHashTable { //! Get the next batch of data from the scan structure void Next(DataChunk &keys, DataChunk &left, DataChunk &result); //! Are pointer chains all pointing to NULL? - bool PointersExhausted(); + bool PointersExhausted() const; private: //! Next operator for the inner join @@ -87,6 +96,8 @@ class JoinHashTable { void NextSemiJoin(DataChunk &keys, DataChunk &left, DataChunk &result); //! Next operator for the anti join void NextAntiJoin(DataChunk &keys, DataChunk &left, DataChunk &result); + //! Next operator for the RIGHT semi and anti join + void NextRightSemiOrAntiJoin(DataChunk &keys, DataChunk &left, DataChunk &result); //! Next operator for the left outer join void NextLeftJoin(DataChunk &keys, DataChunk &left, DataChunk &result); //! Next operator for the mark join @@ -105,7 +116,6 @@ class JoinHashTable { idx_t ScanInnerJoin(DataChunk &keys, SelectionVector &result_vector); public: - void InitializeSelectionVector(const SelectionVector *¤t_sel); void AdvancePointers(); void AdvancePointers(const SelectionVector &sel, idx_t sel_count); void GatherResult(Vector &result, const SelectionVector &result_vector, const SelectionVector &sel_vector, @@ -115,6 +125,38 @@ class JoinHashTable { }; public: + struct SharedState { + + SharedState(); + + // The ptrs to the row to which a key should be inserted into during building + // or matched against during probing + Vector rhs_row_locations; + + SelectionVector salt_match_sel; + SelectionVector key_no_match_sel; + }; + + struct ProbeState : SharedState { + + ProbeState(); + + Vector salt_v; + Vector ht_offsets_v; + Vector ht_offsets_dense_v; + + SelectionVector non_empty_sel; + }; + + struct InsertState : SharedState { + InsertState(const unique_ptr &data_collection, + const vector &equality_predicate_columns); + /// Because of the index hick up + SelectionVector remaining_sel; + SelectionVector key_match_sel; + TupleDataChunkState chunk_state; + }; + JoinHashTable(BufferManager &buffer_manager, const vector &conditions, vector build_types, JoinType type, const vector &output_columns); ~JoinHashTable(); @@ -132,8 +174,8 @@ class JoinHashTable { //! ever called. void Finalize(idx_t chunk_idx_from, idx_t chunk_idx_to, bool parallel); //! Probe the HT with the given input chunk, resulting in the given result - unique_ptr Probe(DataChunk &keys, TupleDataChunkState &key_state, - Vector *precomputed_hashes = nullptr); + unique_ptr Probe(DataChunk &keys, TupleDataChunkState &key_state, ProbeState &probe_state, + optional_ptr precomputed_hashes = nullptr); //! Scan the HT to construct the full outer join result void ScanFullOuter(JoinHTScanState &state, Vector &addresses, DataChunk &result); @@ -167,18 +209,38 @@ class JoinHashTable { vector build_types; //! Positions of the columns that need to output const vector &output_columns; - //! The comparison predicates - vector predicates; + //! The comparison predicates that only contain equality predicates + vector equality_predicates; + //! The comparison predicates that contain non-equality predicates + vector non_equality_predicates; + + //! The column indices of the equality predicates to be used to compare the rows + vector equality_predicate_columns; + //! The column indices of the non-equality predicates to be used to compare the rows + vector non_equality_predicate_columns; //! Data column layout TupleDataLayout layout; - //! Efficiently matches rows - RowMatcher row_matcher; - RowMatcher row_matcher_no_match_sel; + //! Matches the equal condition rows during the build phase of the hash join to prevent + //! duplicates in a list because of hash-collisions + RowMatcher row_matcher_build; + //! Efficiently matches the non-equi rows during the probing phase, only there if non_equality_predicates is not + //! empty + unique_ptr row_matcher_probe; + //! Matches the same rows as the row_matcher, but also returns a vector for no matches + unique_ptr row_matcher_probe_no_match_sel; + //! Is true if there are predicates that are not equality predicates and we need to use the matchers during probing + bool needs_chain_matcher; + + //! If there is more than one element in the chain, we need to scan the next elements of the chain + bool chains_longer_than_one; + + //! The capacity of the HT. Is the same as hash_map.GetSize() / sizeof(ht_entry_t) + idx_t capacity; //! The size of an entry as stored in the HashTable idx_t entry_size; //! The total tuple size idx_t tuple_size; - //! Next pointer offset in tuple + //! Next pointer offset in tuple, also used for the position of the hash, which then gets overwritten by the pointer idx_t pointer_offset; //! A constant false column for initialising right outer joins Vector vfound; @@ -213,13 +275,18 @@ class JoinHashTable { const SelectionVector *¤t_sel); void Hash(DataChunk &keys, const SelectionVector &sel, idx_t count, Vector &hashes); - //! Apply a bitmask to the hashes - void ApplyBitmask(Vector &hashes, idx_t count); - void ApplyBitmask(Vector &hashes, const SelectionVector &sel, idx_t count, Vector &pointers); + bool UseSalt() const; + + //! Gets a pointer to the entry in the HT for each of the hashes_v using linear probing. Will update the + //! key_match_sel vector and the count argument to the number and position of the matches + void GetRowPointers(DataChunk &keys, TupleDataChunkState &key_state, ProbeState &state, Vector &hashes_v, + const SelectionVector &sel, idx_t &count, Vector &pointers_result_v, + SelectionVector &match_sel); private: - //! Insert the given set of locations into the HT with the given set of hashes - void InsertHashes(Vector &hashes, idx_t count, data_ptr_t key_locations[], bool parallel); + //! Insert the given set of locations into the HT with the given set of hashes_v + void InsertHashes(Vector &hashes_v, idx_t count, TupleDataChunkState &chunk_state, InsertState &insert_statebool, + bool parallel); idx_t PrepareKeys(DataChunk &keys, vector &vector_data, const SelectionVector *¤t_sel, SelectionVector &sel, bool build_side); @@ -230,10 +297,14 @@ class JoinHashTable { unique_ptr sink_collection; //! The DataCollection holding the main data of the hash table unique_ptr data_collection; + //! The hash map of the HT, created after finalization AllocatedData hash_map; + ht_entry_t *entries; //! Whether or not NULL values are considered equal in each of the comparisons vector null_values_are_equal; + //! An empty tuple that's a "dead end", can be used to stop chains early + unsafe_unique_array dead_end; //! Copying not allowed JoinHashTable(const JoinHashTable &) = delete; @@ -329,9 +400,9 @@ class JoinHashTable { //! Build HT for the next partitioned probe round bool PrepareExternalFinalize(const idx_t max_ht_size); //! Probe whatever we can, sink the rest into a thread-local HT - unique_ptr ProbeAndSpill(DataChunk &keys, TupleDataChunkState &key_state, DataChunk &payload, - ProbeSpill &probe_spill, ProbeSpillLocalAppendState &spill_state, - DataChunk &spill_chunk); + unique_ptr ProbeAndSpill(DataChunk &keys, TupleDataChunkState &key_state, ProbeState &probe_state, + DataChunk &payload, ProbeSpill &probe_spill, + ProbeSpillLocalAppendState &spill_state, DataChunk &spill_chunk); private: //! The current number of radix bits used to partition diff --git a/src/include/duckdb/execution/operator/csv_scanner/base_scanner.hpp b/src/include/duckdb/execution/operator/csv_scanner/base_scanner.hpp index d5acf105231..c32e00b85fc 100644 --- a/src/include/duckdb/execution/operator/csv_scanner/base_scanner.hpp +++ b/src/include/duckdb/execution/operator/csv_scanner/base_scanner.hpp @@ -74,8 +74,8 @@ class BaseScanner { return lines_read; } - idx_t GetIteratorPosition() { - return iterator.pos.buffer_pos; + CSVPosition GetIteratorPosition() { + return iterator.pos; } CSVStateMachine &GetStateMachine(); @@ -95,9 +95,13 @@ class BaseScanner { bool ever_quoted = false; + //! Shared pointer to the buffer_manager, this is shared across multiple scanners + shared_ptr buffer_manager; + //! Skips Notes and/or parts of the data, starting from the top. //! notes are dirty lines on top of the file, before the actual data - void SkipCSVRows(idx_t rows_to_skip); + static CSVIterator SkipCSVRows(shared_ptr buffer_manager, + const shared_ptr &state_machine, idx_t rows_to_skip); protected: //! Boundaries of this scanner @@ -110,9 +114,6 @@ class BaseScanner { //! Hold the current buffer ptr char *buffer_handle_ptr = nullptr; - //! Shared pointer to the buffer_manager, this is shared across multiple scanners - shared_ptr buffer_manager; - //! If this scanner has been initialized bool initialized = false; //! How many lines were read by this scanner diff --git a/src/include/duckdb/execution/operator/csv_scanner/column_count_scanner.hpp b/src/include/duckdb/execution/operator/csv_scanner/column_count_scanner.hpp index de25f08f235..667b2ca847f 100644 --- a/src/include/duckdb/execution/operator/csv_scanner/column_count_scanner.hpp +++ b/src/include/duckdb/execution/operator/csv_scanner/column_count_scanner.hpp @@ -47,7 +47,7 @@ class ColumnCountResult : public ScannerResult { class ColumnCountScanner : public BaseScanner { public: ColumnCountScanner(shared_ptr buffer_manager, const shared_ptr &state_machine, - shared_ptr error_handler); + shared_ptr error_handler, CSVIterator iterator = {}); ColumnCountResult &ParseChunk() override; diff --git a/src/include/duckdb/execution/operator/csv_scanner/csv_buffer_manager.hpp b/src/include/duckdb/execution/operator/csv_scanner/csv_buffer_manager.hpp index c81b2c87ff1..396c60c9ba2 100644 --- a/src/include/duckdb/execution/operator/csv_scanner/csv_buffer_manager.hpp +++ b/src/include/duckdb/execution/operator/csv_scanner/csv_buffer_manager.hpp @@ -22,7 +22,7 @@ class CSVStateMachine; class CSVBufferManager { public: CSVBufferManager(ClientContext &context, const CSVReaderOptions &options, const string &file_path, - const idx_t file_idx); + const idx_t file_idx, bool per_file_single_threaded = false); //! Returns a buffer from a buffer id (starting from 0). If it's in the auto-detection then we cache new buffers //! Otherwise we remove them from the cache if they are already there, or just return them bypassing the cache. shared_ptr GetBuffer(const idx_t buffer_idx); @@ -48,6 +48,7 @@ class CSVBufferManager { ClientContext &context; idx_t skip_rows = 0; bool sniffing = false; + const bool per_file_single_threaded; private: //! Reads next buffer in reference to cached_buffers.front() diff --git a/src/include/duckdb/execution/operator/csv_scanner/csv_file_scanner.hpp b/src/include/duckdb/execution/operator/csv_scanner/csv_file_scanner.hpp index 0ba7c0e02dc..fd77f5e0338 100644 --- a/src/include/duckdb/execution/operator/csv_scanner/csv_file_scanner.hpp +++ b/src/include/duckdb/execution/operator/csv_scanner/csv_file_scanner.hpp @@ -27,10 +27,11 @@ class CSVFileScan { //! Path to this file CSVFileScan(ClientContext &context, const string &file_path, const CSVReaderOptions &options, const idx_t file_idx, const ReadCSVData &bind_data, const vector &column_ids, - const vector &file_schema); + const vector &file_schema, bool per_file_single_threaded); CSVFileScan(ClientContext &context, const string &file_name, CSVReaderOptions &options); + void SetStart(); const string &GetFileName(); const vector &GetNames(); const vector &GetTypes(); @@ -67,5 +68,7 @@ class CSVFileScan { //! Options for this CSV Reader CSVReaderOptions options; + + CSVIterator start_iterator; }; } // namespace duckdb diff --git a/src/include/duckdb/execution/operator/csv_scanner/csv_reader_options.hpp b/src/include/duckdb/execution/operator/csv_scanner/csv_reader_options.hpp index 2e944369ead..4f9c57b7a0c 100644 --- a/src/include/duckdb/execution/operator/csv_scanner/csv_reader_options.hpp +++ b/src/include/duckdb/execution/operator/csv_scanner/csv_reader_options.hpp @@ -136,7 +136,8 @@ struct CSVReaderOptions { string GetEscape() const; void SetEscape(const string &escape); - int64_t GetSkipRows() const; + idx_t GetSkipRows() const; + void SetSkipRows(int64_t rows); string GetQuote() const; diff --git a/src/include/duckdb/execution/operator/csv_scanner/csv_sniffer.hpp b/src/include/duckdb/execution/operator/csv_scanner/csv_sniffer.hpp index 59a0c721385..3b76c873ed8 100644 --- a/src/include/duckdb/execution/operator/csv_scanner/csv_sniffer.hpp +++ b/src/include/duckdb/execution/operator/csv_scanner/csv_sniffer.hpp @@ -139,9 +139,6 @@ class CSVSniffer { const vector "erule_candidates, const unordered_map> "e_candidates_map, const unordered_map> &escape_candidates_map); - //! 2.1 If the user set a number of lines to skip, make sure we skip them - //! We skip from the first scanner and then apply information on the remaining scanners. - void SkipLines(vector> &csv_state_machines); //! 3. Analyzes if dialect candidate is a good candidate to be considered, if so, it adds it to the candidates void AnalyzeDialectCandidate(unique_ptr, idx_t &rows_read, idx_t &best_consistent_rows, diff --git a/src/include/duckdb/execution/operator/csv_scanner/scanner_boundary.hpp b/src/include/duckdb/execution/operator/csv_scanner/scanner_boundary.hpp index 7cf9769575a..9e38f9bedbb 100644 --- a/src/include/duckdb/execution/operator/csv_scanner/scanner_boundary.hpp +++ b/src/include/duckdb/execution/operator/csv_scanner/scanner_boundary.hpp @@ -25,11 +25,9 @@ namespace duckdb { //! Information stored in the buffer struct CSVBoundary { - CSVBoundary(idx_t file_idx, idx_t buffer_idx, idx_t buffer_pos, idx_t boundary_idx, idx_t end_pos); + CSVBoundary(idx_t buffer_idx, idx_t buffer_pos, idx_t boundary_idx, idx_t end_pos); CSVBoundary(); void Print(); - //! File index where we start scanning [0-idx], a scanner can never go over one file. - idx_t file_idx = 0; //! Start Buffer index of the file where we start scanning idx_t buffer_idx = 0; //! Start Buffer position of the buffer of the file where we start scanning @@ -43,10 +41,8 @@ struct CSVBoundary { }; struct CSVPosition { - CSVPosition(idx_t file_idx, idx_t buffer_idx, idx_t buffer_pos); + CSVPosition(idx_t buffer_idx, idx_t buffer_pos); CSVPosition(); - //! File index where we start scanning [0-idx], a scanner can never go over one file. - idx_t file_idx = 0; //! Start Buffer index of the file where we start scanning idx_t buffer_idx = 0; //! Start Buffer position of the buffer of the file where we start scanning @@ -55,8 +51,6 @@ struct CSVPosition { }; struct CSVIterator { public: - CSVIterator(idx_t file_idx, idx_t buffer_idx, idx_t buffer_pos, idx_t boundary_idx, idx_t buffer_size); - CSVIterator(); void Print(); @@ -68,12 +62,13 @@ struct CSVIterator { //! Getters idx_t GetEndPos() const; - idx_t GetFileIdx() const; idx_t GetBufferIdx() const; idx_t GetBoundaryIdx() const; void SetCurrentPositionToBoundary(); + void SetCurrentBoundaryToPosition(bool single_threaded); + void SetStart(idx_t pos); //! 8 MB TODO: Should benchmarks other values @@ -83,6 +78,8 @@ struct CSVIterator { bool done = false; + bool first_one = true; + private: //! The original setting CSVBoundary boundary; diff --git a/src/include/duckdb/execution/operator/csv_scanner/string_value_scanner.hpp b/src/include/duckdb/execution/operator/csv_scanner/string_value_scanner.hpp index cf639132191..504f42d5334 100644 --- a/src/include/duckdb/execution/operator/csv_scanner/string_value_scanner.hpp +++ b/src/include/duckdb/execution/operator/csv_scanner/string_value_scanner.hpp @@ -247,6 +247,9 @@ class StringValueResult : public ScannerResult { DataChunk &ToChunk(); //! Resets the state of the result void Reset(); + + //! BOM skipping (https://en.wikipedia.org/wiki/Byte_order_mark) + void SkipBOM(); }; //! Our dialect scanner basically goes over the CSV and actually parses the values to a DuckDB vector of string_t @@ -259,7 +262,7 @@ class StringValueScanner : public BaseScanner { StringValueScanner(const shared_ptr &buffer_manager, const shared_ptr &state_machine, - const shared_ptr &error_handler); + const shared_ptr &error_handler, CSVIterator boundary); StringValueResult &ParseChunk() override; @@ -294,9 +297,6 @@ class StringValueScanner : public BaseScanner { //! Function used to move from one buffer to the other, if necessary bool MoveToNextBuffer(); - //! BOM skipping (https://en.wikipedia.org/wiki/Byte_order_mark) - void SkipBOM(); - void SkipUntilNewLine(); void SetStart(); diff --git a/src/include/duckdb/execution/operator/persistent/physical_batch_copy_to_file.hpp b/src/include/duckdb/execution/operator/persistent/physical_batch_copy_to_file.hpp index bb7697876d4..c8813ca4bb8 100644 --- a/src/include/duckdb/execution/operator/persistent/physical_batch_copy_to_file.hpp +++ b/src/include/duckdb/execution/operator/persistent/physical_batch_copy_to_file.hpp @@ -8,11 +8,11 @@ #pragma once -#include "duckdb/execution/physical_operator.hpp" -#include "duckdb/parser/parsed_data/copy_info.hpp" -#include "duckdb/function/copy_function.hpp" #include "duckdb/common/file_system.hpp" #include "duckdb/common/filename_pattern.hpp" +#include "duckdb/execution/physical_operator.hpp" +#include "duckdb/function/copy_function.hpp" +#include "duckdb/parser/parsed_data/copy_info.hpp" namespace duckdb { struct FixedRawBatchData; @@ -29,6 +29,7 @@ class PhysicalBatchCopyToFile : public PhysicalOperator { unique_ptr bind_data; string file_path; bool use_tmp_file; + CopyFunctionReturnType return_type; public: // Source interface diff --git a/src/include/duckdb/execution/operator/persistent/physical_copy_to_file.hpp b/src/include/duckdb/execution/operator/persistent/physical_copy_to_file.hpp index 5f27f25dfcc..8a818dadc0c 100644 --- a/src/include/duckdb/execution/operator/persistent/physical_copy_to_file.hpp +++ b/src/include/duckdb/execution/operator/persistent/physical_copy_to_file.hpp @@ -8,12 +8,13 @@ #pragma once +#include "duckdb/common/enums/copy_overwrite_mode.hpp" #include "duckdb/common/file_system.hpp" #include "duckdb/common/filename_pattern.hpp" #include "duckdb/execution/physical_operator.hpp" #include "duckdb/function/copy_function.hpp" #include "duckdb/parser/parsed_data/copy_info.hpp" -#include "duckdb/common/enums/copy_overwrite_mode.hpp" +#include "duckdb/storage/storage_lock.hpp" namespace duckdb { @@ -37,6 +38,7 @@ class PhysicalCopyToFile : public PhysicalOperator { bool per_thread_output; optional_idx file_size_bytes; bool rotate; + CopyFunctionReturnType return_type; bool partition_output; vector partition_columns; @@ -73,10 +75,12 @@ class PhysicalCopyToFile : public PhysicalOperator { } static void MoveTmpFile(ClientContext &context, const string &tmp_file_path); + static string GetNonTmpFile(ClientContext &context, const string &tmp_file_path); string GetTrimmedPath(ClientContext &context) const; private: - unique_ptr CreateFileState(ClientContext &context, GlobalSinkState &sink) const; + unique_ptr CreateFileState(ClientContext &context, GlobalSinkState &sink, + StorageLockKey &global_lock) const; }; } // namespace duckdb diff --git a/src/include/duckdb/execution/operator/projection/physical_tableinout_function.hpp b/src/include/duckdb/execution/operator/projection/physical_tableinout_function.hpp index 659e5cc4a40..b1d42dd9951 100644 --- a/src/include/duckdb/execution/operator/projection/physical_tableinout_function.hpp +++ b/src/include/duckdb/execution/operator/projection/physical_tableinout_function.hpp @@ -39,6 +39,8 @@ class PhysicalTableInOutFunction : public PhysicalOperator { return function.in_out_function_final; } + string ParamsToString() const override; + private: //! The table function TableFunction function; diff --git a/src/include/duckdb/execution/operator/scan/physical_table_scan.hpp b/src/include/duckdb/execution/operator/scan/physical_table_scan.hpp index e00a18ec51f..e08a91cb663 100644 --- a/src/include/duckdb/execution/operator/scan/physical_table_scan.hpp +++ b/src/include/duckdb/execution/operator/scan/physical_table_scan.hpp @@ -26,7 +26,7 @@ class PhysicalTableScan : public PhysicalOperator { PhysicalTableScan(vector types, TableFunction function, unique_ptr bind_data, vector returned_types, vector column_ids, vector projection_ids, vector names, unique_ptr table_filters, idx_t estimated_cardinality, - ExtraOperatorInfo extra_info); + ExtraOperatorInfo extra_info, vector parameters); //! The table function TableFunction function; @@ -44,6 +44,8 @@ class PhysicalTableScan : public PhysicalOperator { unique_ptr table_filters; //! Currently stores any filters applied to file names (as strings) ExtraOperatorInfo extra_info; + //! Parameters + vector parameters; public: string GetName() const override; diff --git a/src/include/duckdb/function/compression_function.hpp b/src/include/duckdb/function/compression_function.hpp index e34e2d0c35e..6a9f31f4ede 100644 --- a/src/include/duckdb/function/compression_function.hpp +++ b/src/include/duckdb/function/compression_function.hpp @@ -26,6 +26,7 @@ struct ColumnSegmentState; struct ColumnFetchState; struct ColumnScanState; +struct PrefetchState; struct SegmentScanState; struct AnalyzeState { @@ -128,6 +129,7 @@ typedef void (*compression_compress_finalize_t)(CompressionState &state); //===--------------------------------------------------------------------===// // Uncompress / Scan //===--------------------------------------------------------------------===// +typedef void (*compression_init_prefetch_t)(ColumnSegment &segment, PrefetchState &prefetch_state); typedef unique_ptr (*compression_init_segment_scan_t)(ColumnSegment &segment); //! Function prototype used for reading an entire vector (STANDARD_VECTOR_SIZE) @@ -178,13 +180,14 @@ class CompressionFunction { compression_revert_append_t revert_append = nullptr, compression_serialize_state_t serialize_state = nullptr, compression_deserialize_state_t deserialize_state = nullptr, - compression_cleanup_state_t cleanup_state = nullptr) + compression_cleanup_state_t cleanup_state = nullptr, + compression_init_prefetch_t init_prefetch = nullptr) : type(type), data_type(data_type), init_analyze(init_analyze), analyze(analyze), final_analyze(final_analyze), init_compression(init_compression), compress(compress), compress_finalize(compress_finalize), - init_scan(init_scan), scan_vector(scan_vector), scan_partial(scan_partial), fetch_row(fetch_row), skip(skip), - init_segment(init_segment), init_append(init_append), append(append), finalize_append(finalize_append), - revert_append(revert_append), serialize_state(serialize_state), deserialize_state(deserialize_state), - cleanup_state(cleanup_state) { + init_prefetch(init_prefetch), init_scan(init_scan), scan_vector(scan_vector), scan_partial(scan_partial), + fetch_row(fetch_row), skip(skip), init_segment(init_segment), init_append(init_append), append(append), + finalize_append(finalize_append), revert_append(revert_append), serialize_state(serialize_state), + deserialize_state(deserialize_state), cleanup_state(cleanup_state) { } //! Compression type @@ -213,6 +216,8 @@ class CompressionFunction { //! compress_finalize is called after compression_compress_finalize_t compress_finalize; + //! Initialize prefetch state with required I/O data to scan this segment + compression_init_prefetch_t init_prefetch; //! init_scan is called to set up the scan state compression_init_segment_scan_t init_scan; //! scan_vector scans an entire vector using the scan state diff --git a/src/include/duckdb/function/copy_function.hpp b/src/include/duckdb/function/copy_function.hpp index 959fb78857f..17350eef386 100644 --- a/src/include/duckdb/function/copy_function.hpp +++ b/src/include/duckdb/function/copy_function.hpp @@ -114,6 +114,10 @@ enum class CopyTypeSupport { SUPPORTED, LOSSY, UNSUPPORTED }; typedef CopyTypeSupport (*copy_supports_type_t)(const LogicalType &type); +enum class CopyFunctionReturnType : uint8_t { CHANGED_ROWS = 0, CHANGED_ROWS_AND_FILE_LIST = 1 }; +vector GetCopyFunctionReturnNames(CopyFunctionReturnType return_type); +vector GetCopyFunctionReturnLogicalTypes(CopyFunctionReturnType return_type); + class CopyFunction : public Function { // NOLINT: work-around bug in clang-tidy public: explicit CopyFunction(const string &name) diff --git a/src/include/duckdb/function/replacement_scan.hpp b/src/include/duckdb/function/replacement_scan.hpp index 68a98a79b0f..70572c209a4 100644 --- a/src/include/duckdb/function/replacement_scan.hpp +++ b/src/include/duckdb/function/replacement_scan.hpp @@ -36,11 +36,10 @@ struct ReplacementScanData { struct ReplacementScanInput { public: - ReplacementScanInput(TableRef &ref, const string &table_name) : ref(ref), table_name(table_name) { + explicit ReplacementScanInput(const string &table_name) : table_name(table_name) { } public: - TableRef &ref; const string &table_name; }; diff --git a/src/include/duckdb/function/scalar/regexp.hpp b/src/include/duckdb/function/scalar/regexp.hpp index 1b33d3c77fc..fa6a3e91f81 100644 --- a/src/include/duckdb/function/scalar/regexp.hpp +++ b/src/include/duckdb/function/scalar/regexp.hpp @@ -106,9 +106,12 @@ struct RegexStringPieceArgs { } RegexStringPieceArgs &operator=(RegexStringPieceArgs &&other) noexcept { - std::swap(this->size, other.size); - std::swap(this->capacity, other.capacity); - std::swap(this->group_buffer, other.group_buffer); + this->size = other.size; + this->capacity = other.capacity; + this->group_buffer = other.group_buffer; + other.size = 0; + other.capacity = 0; + other.group_buffer = nullptr; return *this; } diff --git a/src/include/duckdb/function/scalar/string_functions.hpp b/src/include/duckdb/function/scalar/string_functions.hpp index c96c2b3c33c..743b5b76239 100644 --- a/src/include/duckdb/function/scalar/string_functions.hpp +++ b/src/include/duckdb/function/scalar/string_functions.hpp @@ -9,7 +9,7 @@ #pragma once #include "duckdb/function/function_set.hpp" -#include "utf8proc.hpp" +#include "utf8proc_wrapper.hpp" #include "duckdb/function/built_in_functions.hpp" namespace duckdb_re2 { @@ -44,6 +44,11 @@ struct StripAccentsFun { struct ConcatFun { static void RegisterFunction(BuiltinFunctions &set); + static ScalarFunction GetFunction(); +}; + +struct ConcatWSFun { + static void RegisterFunction(BuiltinFunctions &set); }; struct LengthFun { @@ -69,13 +74,8 @@ struct LengthFun { auto input_length = input.GetSize(); for (idx_t i = 0; i < input_length; i++) { if (input_data[i] & 0x80) { - int64_t length = 0; // non-ascii character: use grapheme iterator on remainder of string - utf8proc_grapheme_callback(input_data, input_length, [&](size_t start, size_t end) { - length++; - return true; - }); - return length; + return UnsafeNumericCast(Utf8Proc::GraphemeCount(input_data, input_length)); } } return UnsafeNumericCast(input_length); diff --git a/src/include/duckdb/function/table_function.hpp b/src/include/duckdb/function/table_function.hpp index 503a3b2acb2..c03ed17a1f1 100644 --- a/src/include/duckdb/function/table_function.hpp +++ b/src/include/duckdb/function/table_function.hpp @@ -85,7 +85,7 @@ struct TableFunctionBindInput { TableFunctionBindInput(vector &inputs, named_parameter_map_t &named_parameters, vector &input_table_types, vector &input_table_names, optional_ptr info, optional_ptr binder, - const TableFunction &table_function, const TableFunctionRef &ref) + TableFunction &table_function, const TableFunctionRef &ref) : inputs(inputs), named_parameters(named_parameters), input_table_types(input_table_types), input_table_names(input_table_names), info(info), binder(binder), table_function(table_function), ref(ref) { } @@ -96,7 +96,7 @@ struct TableFunctionBindInput { vector &input_table_names; optional_ptr info; optional_ptr binder; - const TableFunction &table_function; + TableFunction &table_function; const TableFunctionRef &ref; }; diff --git a/src/include/duckdb/main/appender.hpp b/src/include/duckdb/main/appender.hpp index 9f58e183baf..9662e274408 100644 --- a/src/include/duckdb/main/appender.hpp +++ b/src/include/duckdb/main/appender.hpp @@ -27,10 +27,11 @@ enum class AppenderType : uint8_t { //! The Appender class can be used to append elements to a table. class BaseAppender { -protected: +public: //! The amount of tuples that will be gathered in the column data collection before flushing - static constexpr const idx_t FLUSH_COUNT = STANDARD_VECTOR_SIZE * 100ULL; + static constexpr const idx_t DEFAULT_FLUSH_COUNT = STANDARD_VECTOR_SIZE * 100ULL; +protected: Allocator &allocator; //! The append types vector types; @@ -42,10 +43,13 @@ class BaseAppender { idx_t column = 0; //! The type of the appender AppenderType appender_type; + //! The amount of rows after which we flush the appender automatically + idx_t flush_count = DEFAULT_FLUSH_COUNT; protected: DUCKDB_API BaseAppender(Allocator &allocator, AppenderType type); - DUCKDB_API BaseAppender(Allocator &allocator, vector types, AppenderType type); + DUCKDB_API BaseAppender(Allocator &allocator, vector types, AppenderType type, + idx_t flush_count = DEFAULT_FLUSH_COUNT); public: DUCKDB_API virtual ~BaseAppender(); @@ -114,12 +118,17 @@ class Appender : public BaseAppender { shared_ptr context; //! The table description (including column names) unique_ptr description; + //! The default expressions + unordered_map default_values; public: DUCKDB_API Appender(Connection &con, const string &schema_name, const string &table_name); DUCKDB_API Appender(Connection &con, const string &table_name); DUCKDB_API ~Appender() override; +public: + void AppendDefault(); + protected: void FlushInternal(ColumnDataCollection &collection) override; }; @@ -131,7 +140,8 @@ class InternalAppender : public BaseAppender { TableCatalogEntry &table; public: - DUCKDB_API InternalAppender(ClientContext &context, TableCatalogEntry &table); + DUCKDB_API InternalAppender(ClientContext &context, TableCatalogEntry &table, + idx_t flush_count = DEFAULT_FLUSH_COUNT); DUCKDB_API ~InternalAppender() override; protected: diff --git a/src/include/duckdb/main/client_context.hpp b/src/include/duckdb/main/client_context.hpp index 202b37bb99c..24898f8d625 100644 --- a/src/include/duckdb/main/client_context.hpp +++ b/src/include/duckdb/main/client_context.hpp @@ -174,7 +174,6 @@ class ClientContext : public enable_shared_from_this { //! Whether or not the given result object (streaming query result or pending query result) is active DUCKDB_API bool IsActiveResult(ClientContextLock &lock, BaseQueryResult &result); - DUCKDB_API void SetActiveResult(ClientContextLock &lock, BaseQueryResult &result); //! Returns the current executor Executor &GetExecutor(); diff --git a/src/include/duckdb/main/relation/query_relation.hpp b/src/include/duckdb/main/relation/query_relation.hpp index f35a8133cd7..478afd9064b 100644 --- a/src/include/duckdb/main/relation/query_relation.hpp +++ b/src/include/duckdb/main/relation/query_relation.hpp @@ -27,6 +27,7 @@ class QueryRelation : public Relation { static unique_ptr ParseStatement(ClientContext &context, const string &query, const string &error); unique_ptr GetQueryNode() override; unique_ptr GetTableRef() override; + BoundStatement Bind(Binder &binder) override; const vector &Columns() override; string ToString(idx_t depth) override; diff --git a/src/include/duckdb/optimizer/join_order/cardinality_estimator.hpp b/src/include/duckdb/optimizer/join_order/cardinality_estimator.hpp index e4862ff5785..5390357102b 100644 --- a/src/include/duckdb/optimizer/join_order/cardinality_estimator.hpp +++ b/src/include/duckdb/optimizer/join_order/cardinality_estimator.hpp @@ -14,7 +14,17 @@ namespace duckdb { -struct FilterInfo; +class FilterInfo; + +struct DenomInfo { + DenomInfo(JoinRelationSet &numerator_relations, double filter_strength, double denominator) + : numerator_relations(numerator_relations), filter_strength(filter_strength), denominator(denominator) { + } + + JoinRelationSet &numerator_relations; + double filter_strength; + double denominator; +}; struct RelationsToTDom { //! column binding sets that are equivalent in a join plan. @@ -25,7 +35,7 @@ struct RelationsToTDom { //! the estimated total domains of each relation without using HLL idx_t tdom_no_hll; bool has_tdom_hll; - vector filters; + vector> filters; vector column_names; explicit RelationsToTDom(const column_binding_set_t &column_binding_set) @@ -33,23 +43,43 @@ struct RelationsToTDom { has_tdom_hll(false) {}; }; +class FilterInfoWithTotalDomains { +public: + FilterInfoWithTotalDomains(optional_ptr filter_info, RelationsToTDom &relation2tdom) + : filter_info(filter_info), tdom_hll(relation2tdom.tdom_hll), tdom_no_hll(relation2tdom.tdom_no_hll), + has_tdom_hll(relation2tdom.has_tdom_hll) { + } + + optional_ptr filter_info; + //! the estimated total domains of the equivalent relations determined using HLL + idx_t tdom_hll; + //! the estimated total domains of each relation without using HLL + idx_t tdom_no_hll; + bool has_tdom_hll; +}; + struct Subgraph2Denominator { - unordered_set relations; + optional_ptr relations; + optional_ptr numerator_relations; double denom; - Subgraph2Denominator() : relations(), denom(1) {}; + Subgraph2Denominator() : relations(nullptr), numerator_relations(nullptr), denom(1) {}; }; class CardinalityHelper { public: CardinalityHelper() { } - CardinalityHelper(double cardinality_before_filters, double filter_string) - : cardinality_before_filters(cardinality_before_filters), filter_strength(filter_string) {}; + explicit CardinalityHelper(double cardinality_before_filters) + : cardinality_before_filters(cardinality_before_filters) {}; public: + // must be a double. Otherwise we can lose significance between different join orders. + // our cardinality estimator severely underestimates cardinalities for 3+ joins. However, + // if one join order has an estimate of 0.8, and another has an estimate of 0.6, rounding + // them means there is no estimated difference, when in reality there could be a very large + // difference. double cardinality_before_filters; - double filter_strength; vector table_names_joined; vector column_names; @@ -57,6 +87,7 @@ class CardinalityHelper { class CardinalityEstimator { public: + static constexpr double DEFAULT_SEMI_ANTI_SELECTIVITY = 5; explicit CardinalityEstimator() {}; private: @@ -82,12 +113,21 @@ class CardinalityEstimator { void PrintRelationToTdomInfo(); private: - bool SingleRelationFilter(FilterInfo &filter_info); - vector DetermineMatchingEquivalentSets(FilterInfo *filter_info); + double GetNumerator(JoinRelationSet &set); + DenomInfo GetDenominator(JoinRelationSet &set); + + bool SingleColumnFilter(FilterInfo &filter_info); + vector DetermineMatchingEquivalentSets(optional_ptr filter_info); //! Given a filter, add the column bindings to the matching equivalent set at the index //! given in matching equivalent sets. //! If there are multiple equivalence sets, they are merged. - void AddToEquivalenceSets(FilterInfo *filter_info, vector matching_equivalent_sets); + void AddToEquivalenceSets(optional_ptr filter_info, vector matching_equivalent_sets); + + double CalculateUpdatedDenom(Subgraph2Denominator left, Subgraph2Denominator right, + FilterInfoWithTotalDomains &filter); + JoinRelationSet &UpdateNumeratorRelations(Subgraph2Denominator left, Subgraph2Denominator right, + FilterInfoWithTotalDomains &filter); + void AddRelationTdom(FilterInfo &filter_info); bool EmptyFilter(FilterInfo &filter_info); }; diff --git a/src/include/duckdb/optimizer/join_order/cost_model.hpp b/src/include/duckdb/optimizer/join_order/cost_model.hpp index 446a127e19e..d6a9245b8ed 100644 --- a/src/include/duckdb/optimizer/join_order/cost_model.hpp +++ b/src/include/duckdb/optimizer/join_order/cost_model.hpp @@ -8,6 +8,7 @@ #pragma once #include "duckdb/optimizer/join_order/join_node.hpp" +#include "duckdb/common/enums/join_type.hpp" #include "duckdb/optimizer/join_order/cardinality_estimator.hpp" namespace duckdb { diff --git a/src/include/duckdb/optimizer/join_order/query_graph.hpp b/src/include/duckdb/optimizer/join_order/query_graph.hpp index f1c2ded0391..e5ac6713897 100644 --- a/src/include/duckdb/optimizer/join_order/query_graph.hpp +++ b/src/include/duckdb/optimizer/join_order/query_graph.hpp @@ -23,7 +23,7 @@ namespace duckdb { -struct FilterInfo; +class FilterInfo; struct NeighborInfo { explicit NeighborInfo(optional_ptr neighbor) : neighbor(neighbor) { diff --git a/src/include/duckdb/optimizer/join_order/query_graph_manager.hpp b/src/include/duckdb/optimizer/join_order/query_graph_manager.hpp index af030b45e16..f5d324bf397 100644 --- a/src/include/duckdb/optimizer/join_order/query_graph_manager.hpp +++ b/src/include/duckdb/optimizer/join_order/query_graph_manager.hpp @@ -9,13 +9,12 @@ #pragma once #include "duckdb/common/common.hpp" +#include "duckdb/common/enums/join_type.hpp" #include "duckdb/common/optional_ptr.hpp" #include "duckdb/common/pair.hpp" -#include "duckdb/common/enums/join_type.hpp" #include "duckdb/common/unordered_map.hpp" #include "duckdb/common/unordered_set.hpp" #include "duckdb/common/vector.hpp" - #include "duckdb/optimizer/join_order/join_node.hpp" #include "duckdb/optimizer/join_order/join_relation.hpp" #include "duckdb/optimizer/join_order/query_graph.hpp" @@ -27,6 +26,8 @@ namespace duckdb { +class QueryGraphEdges; + struct GenerateJoinRelation { GenerateJoinRelation(optional_ptr set, unique_ptr op_p) : set(set), op(std::move(op_p)) { @@ -38,14 +39,18 @@ struct GenerateJoinRelation { //! Filter info struct that is used by the cardinality estimator to set the initial cardinality //! but is also eventually transformed into a query edge. -struct FilterInfo { - FilterInfo(unique_ptr filter, JoinRelationSet &set, idx_t filter_index) - : filter(std::move(filter)), set(set), filter_index(filter_index) { +class FilterInfo { +public: + FilterInfo(unique_ptr filter, JoinRelationSet &set, idx_t filter_index, + JoinType join_type = JoinType::INNER) + : filter(std::move(filter)), set(set), filter_index(filter_index), join_type(join_type) { } +public: unique_ptr filter; JoinRelationSet &set; idx_t filter_index; + JoinType join_type; optional_ptr left_set; optional_ptr right_set; ColumnBinding left_binding; diff --git a/src/include/duckdb/optimizer/join_order/relation_manager.hpp b/src/include/duckdb/optimizer/join_order/relation_manager.hpp index 54d557adddc..8e25b796c74 100644 --- a/src/include/duckdb/optimizer/join_order/relation_manager.hpp +++ b/src/include/duckdb/optimizer/join_order/relation_manager.hpp @@ -20,7 +20,7 @@ namespace duckdb { -struct FilterInfo; +class FilterInfo; //! Represents a single relation and any metadata accompanying that relation struct SingleJoinRelation { diff --git a/src/include/duckdb/parser/expression/function_expression.hpp b/src/include/duckdb/parser/expression/function_expression.hpp index 291883df656..f78ae7fee07 100644 --- a/src/include/duckdb/parser/expression/function_expression.hpp +++ b/src/include/duckdb/parser/expression/function_expression.hpp @@ -61,6 +61,9 @@ class FunctionExpression : public ParsedExpression { void Verify() const override; + //! Returns true, if the function has a lambda expression as a child. + bool IsLambdaFunction() const; + public: template static string ToString(const T &entry, const string &catalog, const string &schema, const string &function_name, diff --git a/src/include/duckdb/parser/parsed_data/transaction_info.hpp b/src/include/duckdb/parser/parsed_data/transaction_info.hpp index b1cb22030f9..ffbc5f128ce 100644 --- a/src/include/duckdb/parser/parsed_data/transaction_info.hpp +++ b/src/include/duckdb/parser/parsed_data/transaction_info.hpp @@ -14,6 +14,12 @@ namespace duckdb { enum class TransactionType : uint8_t { INVALID, BEGIN_TRANSACTION, COMMIT, ROLLBACK }; +enum class TransactionModifierType : uint8_t { + TRANSACTION_DEFAULT_MODIFIER, + TRANSACTION_READ_ONLY, + TRANSACTION_READ_WRITE +}; + struct TransactionInfo : public ParseInfo { public: static constexpr const ParseInfoType TYPE = ParseInfoType::TRANSACTION_INFO; @@ -23,12 +29,15 @@ struct TransactionInfo : public ParseInfo { //! The type of transaction statement TransactionType type; + //! Whether or not a transaction can make modifications to the database + TransactionModifierType modifier; public: void Serialize(Serializer &serializer) const override; static unique_ptr Deserialize(Deserializer &deserializer); string ToString() const; + unique_ptr Copy() const; private: TransactionInfo(); diff --git a/src/include/duckdb/parser/statement/transaction_statement.hpp b/src/include/duckdb/parser/statement/transaction_statement.hpp index 5f7bf184c5d..3fb5f54fdf8 100644 --- a/src/include/duckdb/parser/statement/transaction_statement.hpp +++ b/src/include/duckdb/parser/statement/transaction_statement.hpp @@ -18,7 +18,7 @@ class TransactionStatement : public SQLStatement { static constexpr const StatementType TYPE = StatementType::TRANSACTION_STATEMENT; public: - explicit TransactionStatement(TransactionType type); + explicit TransactionStatement(unique_ptr info); unique_ptr info; diff --git a/src/include/duckdb/parser/tableref.hpp b/src/include/duckdb/parser/tableref.hpp index d88142cf7c2..3c2efbedd77 100644 --- a/src/include/duckdb/parser/tableref.hpp +++ b/src/include/duckdb/parser/tableref.hpp @@ -35,6 +35,8 @@ class TableRef { optional_idx query_location; // External dependencies of this table function shared_ptr external_dependency; + //! Aliases for the column names + vector column_name_alias; public: //! Convert the object to a string diff --git a/src/include/duckdb/parser/tableref/basetableref.hpp b/src/include/duckdb/parser/tableref/basetableref.hpp index 4401fb2830a..16bc1bb868b 100644 --- a/src/include/duckdb/parser/tableref/basetableref.hpp +++ b/src/include/duckdb/parser/tableref/basetableref.hpp @@ -28,8 +28,6 @@ class BaseTableRef : public TableRef { string schema_name; //! Table name string table_name; - //! Aliases for the column names - vector column_name_alias; public: string ToString() const override; diff --git a/src/include/duckdb/parser/tableref/pivotref.hpp b/src/include/duckdb/parser/tableref/pivotref.hpp index 0d521bede7f..ec19f5d6640 100644 --- a/src/include/duckdb/parser/tableref/pivotref.hpp +++ b/src/include/duckdb/parser/tableref/pivotref.hpp @@ -72,8 +72,6 @@ class PivotRef : public TableRef { vector pivots; //! The groups to pivot over. If none are specified all columns not included in the pivots/aggregate are chosen. vector groups; - //! Aliases for the column names - vector column_name_alias; //! Whether or not to include nulls in the result (UNPIVOT only) bool include_nulls; //! The set of values to pivot on (bound pivot only) diff --git a/src/include/duckdb/parser/tableref/subqueryref.hpp b/src/include/duckdb/parser/tableref/subqueryref.hpp index 5e562ced88f..f93b45ab35a 100644 --- a/src/include/duckdb/parser/tableref/subqueryref.hpp +++ b/src/include/duckdb/parser/tableref/subqueryref.hpp @@ -25,8 +25,6 @@ class SubqueryRef : public TableRef { //! The subquery unique_ptr subquery; - //! Aliases for the column names - vector column_name_alias; public: string ToString() const override; diff --git a/src/include/duckdb/parser/tableref/table_function_ref.hpp b/src/include/duckdb/parser/tableref/table_function_ref.hpp index 7cdc8caa0b3..51c4fd8e331 100644 --- a/src/include/duckdb/parser/tableref/table_function_ref.hpp +++ b/src/include/duckdb/parser/tableref/table_function_ref.hpp @@ -23,7 +23,6 @@ class TableFunctionRef : public TableRef { DUCKDB_API TableFunctionRef(); unique_ptr function; - vector column_name_alias; // if the function takes a subquery as argument its in here unique_ptr subquery; diff --git a/src/include/duckdb/parser/transformer.hpp b/src/include/duckdb/parser/transformer.hpp index 9f4bcde4b58..aa0daf31309 100644 --- a/src/include/duckdb/parser/transformer.hpp +++ b/src/include/duckdb/parser/transformer.hpp @@ -257,9 +257,8 @@ class Transformer { //===--------------------------------------------------------------------===// // Constraints transform //===--------------------------------------------------------------------===// - unique_ptr TransformConstraint(duckdb_libpgquery::PGListCell *cell); - - unique_ptr TransformConstraint(duckdb_libpgquery::PGListCell *cell, ColumnDefinition &column, + unique_ptr TransformConstraint(duckdb_libpgquery::PGListCell &cell); + unique_ptr TransformConstraint(duckdb_libpgquery::PGListCell &cell, ColumnDefinition &column, idx_t index); //===--------------------------------------------------------------------===// diff --git a/src/include/duckdb/planner/binder.hpp b/src/include/duckdb/planner/binder.hpp index 0261e1154d7..78097849157 100644 --- a/src/include/duckdb/planner/binder.hpp +++ b/src/include/duckdb/planner/binder.hpp @@ -55,7 +55,7 @@ struct BoundLimitNode; struct PivotColumnEntry; struct UnpivotEntry; -enum class BindingMode : uint8_t { STANDARD_BINDING, EXTRACT_NAMES }; +enum class BindingMode : uint8_t { STANDARD_BINDING, EXTRACT_NAMES, EXTRACT_REPLACEMENT_SCANS }; enum class BinderType : uint8_t { REGULAR_BINDER, VIEW_BINDER }; struct CorrelatedColumnInfo { @@ -196,7 +196,9 @@ class Binder : public enable_shared_from_this { void SetBindingMode(BindingMode mode); BindingMode GetBindingMode(); void AddTableName(string table_name); + void AddReplacementScan(const string &table_name, unique_ptr replacement); const unordered_set &GetTableNames(); + case_insensitive_map_t> &GetReplacementScans(); optional_ptr GetRootStatement() { return root_statement; } @@ -227,6 +229,8 @@ class Binder : public enable_shared_from_this { BindingMode mode = BindingMode::STANDARD_BINDING; //! Table names extracted for BindingMode::EXTRACT_NAMES unordered_set table_names; + //! Replacement Scans extracted for BindingMode::EXTRACT_REPLACEMENT_SCANS + case_insensitive_map_t> replacement_scans; //! The set of bound views reference_set_t bound_views; //! Used to retrieve CatalogEntry's @@ -331,8 +335,8 @@ class Binder : public enable_shared_from_this { vector> &expressions, vector &arguments, vector ¶meters, named_parameter_map_t &named_parameters, unique_ptr &subquery, ErrorData &error); - bool BindTableInTableOutFunction(vector> &expressions, - unique_ptr &subquery, ErrorData &error); + void BindTableInTableOutFunction(vector> &expressions, + unique_ptr &subquery); unique_ptr BindTableFunction(TableFunction &function, vector parameters); unique_ptr BindTableFunctionInternal(TableFunction &table_function, const TableFunctionRef &ref, vector parameters, diff --git a/src/include/duckdb/planner/expression_binder.hpp b/src/include/duckdb/planner/expression_binder.hpp index 7bfd5a9393c..addfe3864db 100644 --- a/src/include/duckdb/planner/expression_binder.hpp +++ b/src/include/duckdb/planner/expression_binder.hpp @@ -137,10 +137,19 @@ class ExpressionBinder { virtual BindResult BindExpression(unique_ptr &expr_ptr, idx_t depth, bool root_expression = false); - //! Recursively replaces macro parameters with the provided input parameters + //! FIXME: Generalise this for extensibility. + //! Recursively replaces macro parameters with the provided input parameters. void ReplaceMacroParameters(unique_ptr &expr, vector> &lambda_params); - //! Enables special-handling of lambda parameters by tracking them in the lambda_params vector + //! Enables special-handling of lambda parameters during macro replacement by tracking them in the lambda_params + //! vector. void ReplaceMacroParametersInLambda(FunctionExpression &function, vector> &lambda_params); + //! Recursively qualifies column references in ON CONFLICT DO UPDATE SET expressions. + void DoUpdateSetQualify(unique_ptr &expr, const string &table_name, + vector> &lambda_params); + //! Enables special-handling of lambda parameters during ON CONFLICT TO UPDATE SET qualification by tracking them in + //! the lambda_params vector. + void DoUpdateSetQualifyInLambda(FunctionExpression &function, const string &table_name, + vector> &lambda_params); static LogicalType GetExpressionReturnType(const Expression &expr); @@ -207,9 +216,6 @@ class ExpressionBinder { //! Returns true if the function name is an alias for the UNNEST function static bool IsUnnestFunction(const string &function_name); - //! Returns true, if the function contains a lambda expression and is not the '->>' operator - static bool IsLambdaFunction(const FunctionExpression &function); - //! Returns the bind result of binding a lambda or JSON function BindResult TryBindLambdaOrJson(FunctionExpression &function, idx_t depth, CatalogEntry &func); }; diff --git a/src/include/duckdb/planner/logical_operator_visitor.hpp b/src/include/duckdb/planner/logical_operator_visitor.hpp index feb8ca7e1c3..ff0fd75def3 100644 --- a/src/include/duckdb/planner/logical_operator_visitor.hpp +++ b/src/include/duckdb/planner/logical_operator_visitor.hpp @@ -19,7 +19,8 @@ namespace duckdb { //! Visitor pattern on LogicalOperator. class LogicalOperatorVisitor { public: - virtual ~LogicalOperatorVisitor() {}; + virtual ~LogicalOperatorVisitor() { + } virtual void VisitOperator(LogicalOperator &op); virtual void VisitExpression(unique_ptr *expression); diff --git a/src/include/duckdb/planner/operator/logical_copy_to_file.hpp b/src/include/duckdb/planner/operator/logical_copy_to_file.hpp index b4727cbcd0b..3c4a791d387 100644 --- a/src/include/duckdb/planner/operator/logical_copy_to_file.hpp +++ b/src/include/duckdb/planner/operator/logical_copy_to_file.hpp @@ -8,12 +8,12 @@ #pragma once +#include "duckdb/common/enums/copy_overwrite_mode.hpp" #include "duckdb/common/filename_pattern.hpp" #include "duckdb/common/local_file_system.hpp" #include "duckdb/common/optional_idx.hpp" #include "duckdb/function/copy_function.hpp" #include "duckdb/planner/logical_operator.hpp" -#include "duckdb/common/enums/copy_overwrite_mode.hpp" namespace duckdb { @@ -38,6 +38,7 @@ class LogicalCopyToFile : public LogicalOperator { bool per_thread_output; optional_idx file_size_bytes; bool rotate; + CopyFunctionReturnType return_type; bool partition_output; vector partition_columns; @@ -45,13 +46,14 @@ class LogicalCopyToFile : public LogicalOperator { vector expected_types; public: + vector GetColumnBindings() override; idx_t EstimateCardinality(ClientContext &context) override; void Serialize(Serializer &serializer) const override; static unique_ptr Deserialize(Deserializer &deserializer); protected: void ResolveTypes() override { - types.emplace_back(LogicalType::BIGINT); + types = GetCopyFunctionReturnLogicalTypes(return_type); } }; } // namespace duckdb diff --git a/src/include/duckdb/planner/tableref/bound_subqueryref.hpp b/src/include/duckdb/planner/tableref/bound_subqueryref.hpp index fccd21b0b1b..2d1061c98f5 100644 --- a/src/include/duckdb/planner/tableref/bound_subqueryref.hpp +++ b/src/include/duckdb/planner/tableref/bound_subqueryref.hpp @@ -26,7 +26,7 @@ class BoundSubqueryRef : public BoundTableRef { //! The binder used to bind the subquery shared_ptr binder; - //! The bound subquery node + //! The bound subquery node (if any) unique_ptr subquery; }; } // namespace duckdb diff --git a/src/include/duckdb/planner/tableref/bound_table_function.hpp b/src/include/duckdb/planner/tableref/bound_table_function.hpp index 58d61b19577..6aafe2b36b3 100644 --- a/src/include/duckdb/planner/tableref/bound_table_function.hpp +++ b/src/include/duckdb/planner/tableref/bound_table_function.hpp @@ -10,6 +10,7 @@ #include "duckdb/planner/bound_tableref.hpp" #include "duckdb/planner/logical_operator.hpp" +#include "duckdb/planner/tableref/bound_subqueryref.hpp" namespace duckdb { @@ -24,6 +25,7 @@ class BoundTableFunction : public BoundTableRef { } unique_ptr get; + unique_ptr subquery; }; } // namespace duckdb diff --git a/src/include/duckdb/storage/block_manager.hpp b/src/include/duckdb/storage/block_manager.hpp index 738d9defd35..0903b8df7e0 100644 --- a/src/include/duckdb/storage/block_manager.hpp +++ b/src/include/duckdb/storage/block_manager.hpp @@ -39,6 +39,7 @@ class BlockManager { virtual unique_ptr CreateBlock(block_id_t block_id, FileBuffer *source_buffer) = 0; //! Return the next free block id virtual block_id_t GetFreeBlockId() = 0; + virtual block_id_t PeekFreeBlockId() = 0; //! Returns whether or not a specified block is the root block virtual bool IsRootBlock(MetaBlockPointer root) = 0; //! Mark a block as "free"; free blocks are immediately added to the free list and can be immediately overwritten @@ -53,6 +54,8 @@ class BlockManager { virtual idx_t GetMetaBlock() = 0; //! Read the content of the block from disk virtual void Read(Block &block) = 0; + //! Read the content of the block from disk + virtual void ReadBlocks(FileBuffer &buffer, block_id_t start_block, idx_t block_count) = 0; //! Writes the block to disk virtual void Write(FileBuffer &block, block_id_t block_id) = 0; //! Writes the block to disk @@ -66,6 +69,12 @@ class BlockManager { virtual idx_t TotalBlocks() = 0; //! Returns the number of free blocks virtual idx_t FreeBlocks() = 0; + //! Whether or not the attached database is a remote file (e.g. attached over s3/https) + virtual bool IsRemote() { + return false; + } + //! Whether or not the attached database is in-memory + virtual bool InMemory() = 0; //! Truncate the underlying database file after a checkpoint virtual void Truncate(); diff --git a/src/include/duckdb/storage/buffer/block_handle.hpp b/src/include/duckdb/storage/buffer/block_handle.hpp index 1f54f2a4218..ab083a12ee5 100644 --- a/src/include/duckdb/storage/buffer/block_handle.hpp +++ b/src/include/duckdb/storage/buffer/block_handle.hpp @@ -107,6 +107,8 @@ class BlockHandle { private: static BufferHandle Load(shared_ptr &handle, unique_ptr buffer = nullptr); + static BufferHandle LoadFromBuffer(shared_ptr &handle, data_ptr_t data, + unique_ptr reusable_buffer); unique_ptr UnloadAndTakeBlock(); void Unload(); bool CanUnload(); diff --git a/src/include/duckdb/storage/buffer_manager.hpp b/src/include/duckdb/storage/buffer_manager.hpp index e7c6f66ab5e..b4b85612169 100644 --- a/src/include/duckdb/storage/buffer_manager.hpp +++ b/src/include/duckdb/storage/buffer_manager.hpp @@ -39,6 +39,8 @@ class BufferManager { //! Reallocate an in-memory buffer that is pinned. virtual void ReAllocate(shared_ptr &handle, idx_t block_size) = 0; virtual BufferHandle Pin(shared_ptr &handle) = 0; + //! Prefetch a series of blocks. Note that this is a performance suggestion. + virtual void Prefetch(vector> &handles) = 0; virtual void Unpin(shared_ptr &handle) = 0; //! Returns the currently allocated memory diff --git a/src/include/duckdb/storage/in_memory_block_manager.hpp b/src/include/duckdb/storage/in_memory_block_manager.hpp index 0f3985cb91f..7c09541a3cc 100644 --- a/src/include/duckdb/storage/in_memory_block_manager.hpp +++ b/src/include/duckdb/storage/in_memory_block_manager.hpp @@ -29,6 +29,9 @@ class InMemoryBlockManager : public BlockManager { block_id_t GetFreeBlockId() override { throw InternalException("Cannot perform IO in in-memory database - GetFreeBlockId!"); } + block_id_t PeekFreeBlockId() override { + throw InternalException("Cannot perform IO in in-memory database - PeekFreeBlockId!"); + } bool IsRootBlock(MetaBlockPointer root) override { throw InternalException("Cannot perform IO in in-memory database - IsRootBlock!"); } @@ -47,12 +50,18 @@ class InMemoryBlockManager : public BlockManager { void Read(Block &block) override { throw InternalException("Cannot perform IO in in-memory database - Read!"); } + void ReadBlocks(FileBuffer &buffer, block_id_t start_block, idx_t block_count) override { + throw InternalException("Cannot perform IO in in-memory database - ReadBlocks!"); + } void Write(FileBuffer &block, block_id_t block_id) override { throw InternalException("Cannot perform IO in in-memory database - Write!"); } void WriteHeader(DatabaseHeader header) override { throw InternalException("Cannot perform IO in in-memory database - WriteHeader!"); } + bool InMemory() override { + return true; + } idx_t TotalBlocks() override { throw InternalException("Cannot perform IO in in-memory database - TotalBlocks!"); } diff --git a/src/include/duckdb/storage/metadata/metadata_manager.hpp b/src/include/duckdb/storage/metadata/metadata_manager.hpp index 900dde00970..bf01fc1a875 100644 --- a/src/include/duckdb/storage/metadata/metadata_manager.hpp +++ b/src/include/duckdb/storage/metadata/metadata_manager.hpp @@ -68,6 +68,7 @@ class MetadataManager { void ClearModifiedBlocks(const vector &pointers); vector GetMetadataInfo() const; + vector> GetBlocks() const; idx_t BlockCount(); void Write(WriteStream &sink); @@ -81,6 +82,7 @@ class MetadataManager { protected: block_id_t AllocateNewBlock(); + block_id_t PeekNextBlockId(); block_id_t GetNextBlockId(); void AddBlock(MetadataBlock new_block, bool if_exists = false); diff --git a/src/include/duckdb/storage/serialization/parse_info.json b/src/include/duckdb/storage/serialization/parse_info.json index e31378c3d6b..41f9972cb41 100644 --- a/src/include/duckdb/storage/serialization/parse_info.json +++ b/src/include/duckdb/storage/serialization/parse_info.json @@ -570,6 +570,11 @@ "id": 200, "name": "type", "type": "TransactionType" + }, + { + "id": 201, + "name": "modifier", + "type": "TransactionModifierType" } ] }, diff --git a/src/include/duckdb/storage/single_file_block_manager.hpp b/src/include/duckdb/storage/single_file_block_manager.hpp index bdf2e2dbff8..8be4b895ff0 100644 --- a/src/include/duckdb/storage/single_file_block_manager.hpp +++ b/src/include/duckdb/storage/single_file_block_manager.hpp @@ -49,6 +49,8 @@ class SingleFileBlockManager : public BlockManager { unique_ptr CreateBlock(block_id_t block_id, FileBuffer *source_buffer) override; //! Return the next free block id block_id_t GetFreeBlockId() override; + //! Check the next free block id - but do not assign or allocate it + block_id_t PeekFreeBlockId() override; //! Returns whether or not a specified block is the root block bool IsRootBlock(MetaBlockPointer root) override; //! Mark a block as free (immediately re-writeable) @@ -61,6 +63,8 @@ class SingleFileBlockManager : public BlockManager { idx_t GetMetaBlock() override; //! Read the content of the block from disk void Read(Block &block) override; + //! Read the content of a range of blocks into a buffer + void ReadBlocks(FileBuffer &buffer, block_id_t start_block, idx_t block_count) override; //! Write the given block to disk void Write(FileBuffer &block, block_id_t block_id) override; //! Write the header to disk, this is the final step of the checkpointing process @@ -68,10 +72,15 @@ class SingleFileBlockManager : public BlockManager { //! Truncate the underlying database file after a checkpoint void Truncate() override; + bool InMemory() override { + return false; + } //! Returns the number of total blocks idx_t TotalBlocks() override; //! Returns the number of free blocks idx_t FreeBlocks() override; + //! Whether or not the attached database is a remote file + bool IsRemote() override; private: //! Loads the free list of the file. @@ -83,6 +92,8 @@ class SingleFileBlockManager : public BlockManager { void ReadAndChecksum(FileBuffer &handle, uint64_t location) const; void ChecksumAndWrite(FileBuffer &handle, uint64_t location) const; + idx_t GetBlockLocation(block_id_t block_id); + //! Return the blocks to which we will write the free list and modified blocks vector GetFreeListBlocks(); void TrimFreeBlocks(); diff --git a/src/include/duckdb/storage/standard_buffer_manager.hpp b/src/include/duckdb/storage/standard_buffer_manager.hpp index bc4cc6dca7d..57fb7adffb6 100644 --- a/src/include/duckdb/storage/standard_buffer_manager.hpp +++ b/src/include/duckdb/storage/standard_buffer_manager.hpp @@ -65,6 +65,7 @@ class StandardBufferManager : public BufferManager { void ReAllocate(shared_ptr &handle, idx_t block_size) final; BufferHandle Pin(shared_ptr &handle) final; + void Prefetch(vector> &handles) final; void Unpin(shared_ptr &handle) final; //! Set a new memory limit to the buffer manager, throws an exception if the new limit is too low and not enough @@ -142,6 +143,9 @@ class StandardBufferManager : public BufferManager { //! overwrites the data within with garbage. Any readers that do not hold the pin will notice void VerifyZeroReaders(shared_ptr &handle); + void BatchRead(vector> &handles, const map &load_map, + block_id_t first_block, block_id_t last_block); + protected: // These are stored here because temp_directory creation is lazy // so we need to store information related to the temporary directory before it's created diff --git a/src/include/duckdb/storage/storage_info.hpp b/src/include/duckdb/storage/storage_info.hpp index e09419ecda7..8622bbf539a 100644 --- a/src/include/duckdb/storage/storage_info.hpp +++ b/src/include/duckdb/storage/storage_info.hpp @@ -25,7 +25,11 @@ struct FileHandle; //! The default block allocation size. #define DEFAULT_BLOCK_ALLOC_SIZE 262144ULL //! The minimum block allocation size. This is the minimum size we test in our nightly tests. -#define MIN_BLOCK_ALLOC_SIZE 16384 +#define MIN_BLOCK_ALLOC_SIZE 16384ULL + +#ifndef DUCKDB_BLOCK_ALLOC_SIZE +#define DUCKDB_BLOCK_ALLOC_SIZE DEFAULT_BLOCK_ALLOC_SIZE +#endif using block_id_t = int64_t; @@ -35,8 +39,7 @@ struct Storage { //! Block header size for blocks written to the storage constexpr static idx_t BLOCK_HEADER_SIZE = sizeof(uint64_t); //! Size of a memory slot managed by the StorageManager and the BlockManager. - //! Defaults to DEFAULT_BLOCK_ALLOC_SIZE. - constexpr static idx_t BLOCK_ALLOC_SIZE = DEFAULT_BLOCK_ALLOC_SIZE; + constexpr static idx_t BLOCK_ALLOC_SIZE = DUCKDB_BLOCK_ALLOC_SIZE; //! The actual memory space that is available within a block. constexpr static idx_t BLOCK_SIZE = BLOCK_ALLOC_SIZE - BLOCK_HEADER_SIZE; //! The size of the headers. This should be small and written more or less atomically by the hard disk. We default @@ -122,9 +125,18 @@ struct DatabaseHeader { #if (DEFAULT_BLOCK_ALLOC_SIZE & (DEFAULT_BLOCK_ALLOC_SIZE - 1) != 0) #error The default block allocation size must be a power of two #endif +#if (DUCKDB_BLOCK_ALLOC_SIZE & (DUCKDB_BLOCK_ALLOC_SIZE - 1) != 0) +#error The duckdb block allocation size must be a power of two +#endif #if (MIN_BLOCK_ALLOC_SIZE & (MIN_BLOCK_ALLOC_SIZE - 1) != 0) #error The minimum block allocation size must be a power of two #endif +#if (DUCKDB_BLOCK_ALLOC_SIZE > 2147483647) +#error The duckdb block allocation size must not exceed the maximum value of a 32-bit signed integer +#endif +#if (DUCKDB_BLOCK_ALLOC_SIZE < MIN_BLOCK_ALLOC_SIZE) +#error The duckdb block allocation size must be greater or equal than the minimum block allocation size +#endif static_assert(Storage::BLOCK_ALLOC_SIZE % Storage::SECTOR_SIZE == 0, "the block allocation size has to be a multiple of the sector size"); diff --git a/src/include/duckdb/storage/table/array_column_data.hpp b/src/include/duckdb/storage/table/array_column_data.hpp index 8ce7835f190..eb1c865a48c 100644 --- a/src/include/duckdb/storage/table/array_column_data.hpp +++ b/src/include/duckdb/storage/table/array_column_data.hpp @@ -28,6 +28,7 @@ class ArrayColumnData : public ColumnData { void SetStart(idx_t new_start) override; bool CheckZonemap(ColumnScanState &state, TableFilter &filter) override; + void InitializePrefetch(PrefetchState &prefetch_state, ColumnScanState &scan_state, idx_t rows) override; void InitializeScan(ColumnScanState &state) override; void InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) override; diff --git a/src/include/duckdb/storage/table/column_data.hpp b/src/include/duckdb/storage/table/column_data.hpp index fe21efecfd3..28cd114376f 100644 --- a/src/include/duckdb/storage/table/column_data.hpp +++ b/src/include/duckdb/storage/table/column_data.hpp @@ -26,11 +26,11 @@ class RowGroup; class RowGroupWriter; class TableDataWriter; class TableStorageInfo; -struct TransactionData; -struct TableScanOptions; - struct DataTableInfo; +struct PrefetchState; struct RowGroupWriteInfo; +struct TableScanOptions; +struct TransactionData; struct ColumnCheckpointInfo { ColumnCheckpointInfo(RowGroupWriteInfo &info, idx_t column_idx) : info(info), column_idx(column_idx) { @@ -88,6 +88,8 @@ class ColumnData { //! Whether or not we can scan an entire vector virtual ScanVectorType GetVectorScanType(ColumnScanState &state, idx_t scan_count); + //! Initialize prefetch state with required I/O data for the next N rows + virtual void InitializePrefetch(PrefetchState &prefetch_state, ColumnScanState &scan_state, idx_t rows); //! Initialize a scan of the column virtual void InitializeScan(ColumnScanState &state); //! Initialize a scan starting at the specified offset @@ -102,6 +104,7 @@ class ColumnData { virtual void ScanCommittedRange(idx_t row_group_start, idx_t offset_in_row_group, idx_t count, Vector &result); virtual idx_t ScanCount(ColumnScanState &state, Vector &result, idx_t count); + //! Select virtual void Select(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result, SelectionVector &sel, idx_t &count, const TableFilter &filter); diff --git a/src/include/duckdb/storage/table/column_segment.hpp b/src/include/duckdb/storage/table/column_segment.hpp index c5373000c4f..7e5eecc8c25 100644 --- a/src/include/duckdb/storage/table/column_segment.hpp +++ b/src/include/duckdb/storage/table/column_segment.hpp @@ -31,6 +31,7 @@ class TableFilter; struct ColumnFetchState; struct ColumnScanState; struct ColumnAppendState; +struct PrefetchState; enum class ColumnSegmentType : uint8_t { TRANSIENT, PERSISTENT }; //! TableFilter represents a filter pushed down into the table scan. @@ -63,6 +64,7 @@ class ColumnSegment : public SegmentBase { idx_t segment_size = Storage::BLOCK_SIZE); public: + void InitializePrefetch(PrefetchState &prefetch_state, ColumnScanState &scan_state); void InitializeScan(ColumnScanState &state); //! Scan one vector from this segment void Scan(ColumnScanState &state, idx_t scan_count, Vector &result, idx_t result_offset, ScanVectorType scan_type); diff --git a/src/include/duckdb/storage/table/list_column_data.hpp b/src/include/duckdb/storage/table/list_column_data.hpp index 8a29d585850..0287cffa317 100644 --- a/src/include/duckdb/storage/table/list_column_data.hpp +++ b/src/include/duckdb/storage/table/list_column_data.hpp @@ -28,6 +28,7 @@ class ListColumnData : public ColumnData { void SetStart(idx_t new_start) override; bool CheckZonemap(ColumnScanState &state, TableFilter &filter) override; + void InitializePrefetch(PrefetchState &prefetch_state, ColumnScanState &scan_state, idx_t rows) override; void InitializeScan(ColumnScanState &state) override; void InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) override; diff --git a/src/include/duckdb/storage/table/scan_state.hpp b/src/include/duckdb/storage/table/scan_state.hpp index b14813dc68b..9d3d9adb1f5 100644 --- a/src/include/duckdb/storage/table/scan_state.hpp +++ b/src/include/duckdb/storage/table/scan_state.hpp @@ -9,6 +9,7 @@ #pragma once #include "duckdb/common/common.hpp" +#include "duckdb/common/map.hpp" #include "duckdb/storage/buffer/buffer_handle.hpp" #include "duckdb/storage/storage_lock.hpp" #include "duckdb/common/enums/scan_options.hpp" @@ -198,6 +199,14 @@ struct ParallelTableScanState { unique_ptr checkpoint_lock; }; +struct PrefetchState { + ~PrefetchState(); + + void AddBlock(shared_ptr block); + + vector> blocks; +}; + class CreateIndexScanState : public TableScanState { public: vector> locks; diff --git a/src/include/duckdb/storage/table/standard_column_data.hpp b/src/include/duckdb/storage/table/standard_column_data.hpp index 7f88d361755..3d5c28c70ae 100644 --- a/src/include/duckdb/storage/table/standard_column_data.hpp +++ b/src/include/duckdb/storage/table/standard_column_data.hpp @@ -27,6 +27,7 @@ class StandardColumnData : public ColumnData { bool CheckZonemap(ColumnScanState &state, TableFilter &filter) override; ScanVectorType GetVectorScanType(ColumnScanState &state, idx_t scan_count) override; + void InitializePrefetch(PrefetchState &prefetch_state, ColumnScanState &scan_state, idx_t rows) override; void InitializeScan(ColumnScanState &state) override; void InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) override; diff --git a/src/include/duckdb/storage/table/struct_column_data.hpp b/src/include/duckdb/storage/table/struct_column_data.hpp index 80d1025523c..79e3403de3b 100644 --- a/src/include/duckdb/storage/table/struct_column_data.hpp +++ b/src/include/duckdb/storage/table/struct_column_data.hpp @@ -29,6 +29,7 @@ class StructColumnData : public ColumnData { bool CheckZonemap(ColumnScanState &state, TableFilter &filter) override; idx_t GetMaxEntry() override; + void InitializePrefetch(PrefetchState &prefetch_state, ColumnScanState &scan_state, idx_t rows) override; void InitializeScan(ColumnScanState &state) override; void InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) override; diff --git a/src/include/duckdb/transaction/meta_transaction.hpp b/src/include/duckdb/transaction/meta_transaction.hpp index 985e71ce830..3267b8cdc8f 100644 --- a/src/include/duckdb/transaction/meta_transaction.hpp +++ b/src/include/duckdb/transaction/meta_transaction.hpp @@ -34,8 +34,6 @@ class MetaTransaction { idx_t catalog_version; //! The validity checker of the transaction ValidChecker transaction_validity; - //! Whether or not any transaction have made modifications - bool read_only; //! The active query number transaction_t active_query; @@ -55,6 +53,8 @@ class MetaTransaction { idx_t GetActiveQuery(); void SetActiveQuery(transaction_t query_number); + void SetReadOnly(); + bool IsReadOnly() const; void ModifyDatabase(AttachedDatabase &db); optional_ptr ModifiedDatabase() { return modified_database; @@ -72,6 +72,8 @@ class MetaTransaction { vector> all_transactions; //! The database we are modifying - we can only modify one database per transaction optional_ptr modified_database; + //! Whether or not the meta transaction is marked as read only + bool is_read_only; }; } // namespace duckdb diff --git a/src/include/duckdb/transaction/transaction_context.hpp b/src/include/duckdb/transaction/transaction_context.hpp index b0a50103bb4..9623f5a7818 100644 --- a/src/include/duckdb/transaction/transaction_context.hpp +++ b/src/include/duckdb/transaction/transaction_context.hpp @@ -47,6 +47,8 @@ class TransactionContext { return auto_commit; } + void SetReadOnly(); + idx_t GetActiveQuery(); void ResetActiveQuery(); void SetActiveQuery(transaction_t query_number); diff --git a/src/main/appender.cpp b/src/main/appender.cpp index 1a8fae39cf9..564fff2e923 100644 --- a/src/main/appender.cpp +++ b/src/main/appender.cpp @@ -12,6 +12,9 @@ #include "duckdb/main/connection.hpp" #include "duckdb/main/database.hpp" #include "duckdb/storage/data_table.hpp" +#include "duckdb/planner/expression_binder/constant_binder.hpp" +#include "duckdb/planner/expression/bound_constant_expression.hpp" +#include "duckdb/execution/expression_executor.hpp" namespace duckdb { @@ -19,9 +22,10 @@ BaseAppender::BaseAppender(Allocator &allocator, AppenderType type_p) : allocator(allocator), column(0), appender_type(type_p) { } -BaseAppender::BaseAppender(Allocator &allocator_p, vector types_p, AppenderType type_p) +BaseAppender::BaseAppender(Allocator &allocator_p, vector types_p, AppenderType type_p, + idx_t flush_count_p) : allocator(allocator_p), types(std::move(types_p)), collection(make_uniq(allocator, types)), - column(0), appender_type(type_p) { + column(0), appender_type(type_p), flush_count(flush_count_p) { InitializeChunk(); } @@ -40,9 +44,9 @@ void BaseAppender::Destructor() { } } -InternalAppender::InternalAppender(ClientContext &context_p, TableCatalogEntry &table_p) - : BaseAppender(Allocator::DefaultAllocator(), table_p.GetTypes(), AppenderType::PHYSICAL), context(context_p), - table(table_p) { +InternalAppender::InternalAppender(ClientContext &context_p, TableCatalogEntry &table_p, idx_t flush_count_p) + : BaseAppender(Allocator::DefaultAllocator(), table_p.GetTypes(), AppenderType::PHYSICAL, flush_count_p), + context(context_p), table(table_p) { } InternalAppender::~InternalAppender() { @@ -56,9 +60,39 @@ Appender::Appender(Connection &con, const string &schema_name, const string &tab // table could not be found throw CatalogException(StringUtil::Format("Table \"%s.%s\" could not be found", schema_name, table_name)); } + vector> defaults; for (auto &column : description->columns) { types.push_back(column.Type()); + defaults.push_back(column.HasDefaultValue() ? &column.DefaultValue() : nullptr); } + auto binder = Binder::CreateBinder(*context); + + context->RunFunctionInTransaction([&]() { + for (idx_t i = 0; i < types.size(); i++) { + auto &type = types[i]; + auto &expr = defaults[i]; + + if (!expr) { + // Insert NULL + default_values[i] = Value(type); + continue; + } + auto default_copy = expr->Copy(); + D_ASSERT(!default_copy->HasParameter()); + ConstantBinder default_binder(*binder, *context, "DEFAULT value"); + default_binder.target_type = type; + auto bound_default = default_binder.Bind(default_copy); + Value result_value; + if (bound_default->IsFoldable() && + ExpressionExecutor::TryEvaluateScalar(*context, *bound_default, result_value)) { + // Insert the evaluated Value + default_values[i] = result_value; + } else { + // These are not supported currently, we don't add them to the 'default_values' map + } + } + }); + InitializeChunk(); collection = make_uniq(allocator, types); } @@ -339,7 +373,7 @@ void BaseAppender::AppendDataChunk(DataChunk &chunk) { } } collection->Append(chunk); - if (collection->Count() >= FLUSH_COUNT) { + if (collection->Count() >= flush_count) { Flush(); } } @@ -350,7 +384,7 @@ void BaseAppender::FlushChunk() { } collection->Append(chunk); chunk.Reset(); - if (collection->Count() >= FLUSH_COUNT) { + if (collection->Count() >= flush_count) { Flush(); } } @@ -375,6 +409,18 @@ void Appender::FlushInternal(ColumnDataCollection &collection) { context->Append(*description, collection); } +void Appender::AppendDefault() { + auto it = default_values.find(column); + auto &column_def = description->columns[column]; + if (it == default_values.end()) { + throw NotImplementedException( + "AppendDefault is currently not supported for column \"%s\" because default expression is not foldable.", + column_def.Name()); + } + auto &default_value = it->second; + Append(default_value); +} + void InternalAppender::FlushInternal(ColumnDataCollection &collection) { auto binder = Binder::CreateBinder(context); auto bound_constraints = binder->BindConstraints(table); diff --git a/src/main/capi/appender-c.cpp b/src/main/capi/appender-c.cpp index a58376362a9..eed34fb974f 100644 --- a/src/main/capi/appender-c.cpp +++ b/src/main/capi/appender-c.cpp @@ -110,6 +110,24 @@ duckdb_state duckdb_append_internal(duckdb_appender appender, T value) { return DuckDBSuccess; } +duckdb_state duckdb_append_default(duckdb_appender appender) { + if (!appender) { + return DuckDBError; + } + auto *appender_instance = reinterpret_cast(appender); + + try { + appender_instance->appender->AppendDefault(); + } catch (std::exception &ex) { + ErrorData error(ex); + appender_instance->error = error.RawMessage(); + return DuckDBError; + } catch (...) { + return DuckDBError; + } + return DuckDBSuccess; +} + duckdb_state duckdb_append_bool(duckdb_appender appender, bool value) { return duckdb_append_internal(appender, value); } diff --git a/src/main/capi/prepared-c.cpp b/src/main/capi/prepared-c.cpp index 8093cd98d3a..8ac414978f7 100644 --- a/src/main/capi/prepared-c.cpp +++ b/src/main/capi/prepared-c.cpp @@ -338,7 +338,12 @@ duckdb_state duckdb_execute_prepared(duckdb_prepared_statement prepared_statemen return DuckDBError; } - auto result = wrapper->statement->Execute(wrapper->values, false); + duckdb::unique_ptr result; + try { + result = wrapper->statement->Execute(wrapper->values, false); + } catch (...) { + return DuckDBError; + } return DuckDBTranslateResult(std::move(result), out_result); } diff --git a/src/main/client_context.cpp b/src/main/client_context.cpp index aec3abb8891..236908fcdcc 100644 --- a/src/main/client_context.cpp +++ b/src/main/client_context.cpp @@ -754,13 +754,6 @@ bool ClientContext::IsActiveResult(ClientContextLock &lock, BaseQueryResult &res return active_query->IsOpenResult(result); } -void ClientContext::SetActiveResult(ClientContextLock &lock, BaseQueryResult &result) { - if (!active_query) { - return; - } - return active_query->SetOpenResult(result); -} - unique_ptr ClientContext::PendingStatementOrPreparedStatementInternal( ClientContextLock &lock, const string &query, unique_ptr statement, shared_ptr &prepared, const PendingQueryParameters ¶meters) { @@ -1107,7 +1100,7 @@ unique_ptr ClientContext::TableInfo(const string &schema_name, result->schema = schema_name; result->table = table_name; for (auto &column : table->GetColumns().Logical()) { - result->columns.emplace_back(column.Name(), column.Type()); + result->columns.emplace_back(column.Copy()); } }); return result; diff --git a/src/main/extension/extension_helper.cpp b/src/main/extension/extension_helper.cpp index 37b3cd1aa03..bbf98349ccf 100644 --- a/src/main/extension/extension_helper.cpp +++ b/src/main/extension/extension_helper.cpp @@ -380,8 +380,8 @@ 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", - "json", "excel", "sqlsmith", "inet", "jemalloc", "autocomplete"}; + unordered_set extensions {"parquet", "icu", "tpch", "tpcds", "fts", "httpfs", + "json", "excel", "inet", "jemalloc", "autocomplete"}; for (auto &ext : extensions) { LoadExtensionInternal(db, ext, true); } @@ -495,13 +495,6 @@ ExtensionLoadResult ExtensionHelper::LoadExtensionInternal(DuckDB &db, const std #else // excel extension required but not build: skip this test return ExtensionLoadResult::NOT_LOADED; -#endif - } else if (extension == "sqlsmith") { -#if DUCKDB_EXTENSION_SQLSMITH_LINKED - db.LoadStaticExtension(); -#else - // excel extension required but not build: skip this test - return ExtensionLoadResult::NOT_LOADED; #endif } else if (extension == "jemalloc") { #if DUCKDB_EXTENSION_JEMALLOC_LINKED diff --git a/src/main/relation/query_relation.cpp b/src/main/relation/query_relation.cpp index 03a3d62e812..3d30a154481 100644 --- a/src/main/relation/query_relation.cpp +++ b/src/main/relation/query_relation.cpp @@ -1,6 +1,7 @@ #include "duckdb/main/relation/query_relation.hpp" #include "duckdb/main/client_context.hpp" #include "duckdb/parser/statement/select_statement.hpp" +#include "duckdb/parser/expression/star_expression.hpp" #include "duckdb/parser/tableref/subqueryref.hpp" #include "duckdb/parser/tableref/joinref.hpp" #include "duckdb/parser/parser.hpp" @@ -8,27 +9,14 @@ #include "duckdb/planner/binder.hpp" #include "duckdb/parser/query_node/select_node.hpp" #include "duckdb/planner/query_node/bound_select_node.hpp" +#include "duckdb/parser/common_table_expression_info.hpp" namespace duckdb { -static void InitializeTableRefDependency(TableRef &ref) { - if (ref.type == TableReferenceType::JOIN) { - auto &join_ref = ref.Cast(); - InitializeTableRefDependency(*join_ref.right); - InitializeTableRefDependency(*join_ref.left); - } else { - ref.external_dependency = make_shared_ptr(); - } -} - QueryRelation::QueryRelation(const shared_ptr &context, unique_ptr select_stmt_p, string alias_p) : Relation(context, RelationType::QUERY_RELATION), select_stmt(std::move(select_stmt_p)), alias(std::move(alias_p)) { - if (select_stmt->node->type == QueryNodeType::SELECT_NODE) { - auto &ref = *select_stmt->node->Cast().from_table; - InitializeTableRefDependency(ref); - } context->TryBindRelation(*this, this->columns); } @@ -62,6 +50,42 @@ unique_ptr QueryRelation::GetTableRef() { return std::move(subquery_ref); } +BoundStatement QueryRelation::Bind(Binder &binder) { + auto saved_binding_mode = binder.GetBindingMode(); + binder.SetBindingMode(BindingMode::EXTRACT_REPLACEMENT_SCANS); + bool first_bind = columns.empty(); + auto result = Relation::Bind(binder); + auto &replacements = binder.GetReplacementScans(); + if (first_bind) { + auto &query_node = *select_stmt->node; + auto &cte_map = query_node.cte_map; + for (auto &kv : replacements) { + auto &name = kv.first; + auto &tableref = kv.second; + + if (!tableref->external_dependency) { + // Only push a CTE for objects that are out of our control (i.e Python) + // This makes sure replacement scans for files (parquet/csv/json etc) are not transformed into a CTE + continue; + } + + auto select = make_uniq(); + auto select_node = make_uniq(); + select_node->select_list.push_back(make_uniq()); + select_node->from_table = std::move(tableref); + select->node = std::move(select_node); + + auto cte_info = make_uniq(); + cte_info->query = std::move(select); + + cte_map.map[name] = std::move(cte_info); + } + } + replacements.clear(); + binder.SetBindingMode(saved_binding_mode); + return result; +} + string QueryRelation::GetAlias() { return alias; } diff --git a/src/main/settings/settings.cpp b/src/main/settings/settings.cpp index 1841c0a0009..22dda3de413 100644 --- a/src/main/settings/settings.cpp +++ b/src/main/settings/settings.cpp @@ -734,10 +734,9 @@ Value CustomProfilingSettings::GetSetting(const ClientContext &context) { if (!profiling_settings_str.empty()) { profiling_settings_str += ", "; } - profiling_settings_str += EnumUtil::ToString(entry); + profiling_settings_str += StringUtil::Format("\"%s\": \"true\"", EnumUtil::ToString(entry)); } - - return Value(profiling_settings_str); + return Value(StringUtil::Format("{%s}", profiling_settings_str)); } //===--------------------------------------------------------------------===// diff --git a/src/optimizer/column_lifetime_analyzer.cpp b/src/optimizer/column_lifetime_analyzer.cpp index d942e247eb5..1f514e028c9 100644 --- a/src/optimizer/column_lifetime_analyzer.cpp +++ b/src/optimizer/column_lifetime_analyzer.cpp @@ -73,10 +73,6 @@ void ColumnLifetimeAnalyzer::VisitOperator(LogicalOperator &op) { break; } auto &comp_join = op.Cast(); - if (comp_join.join_type == JoinType::MARK || comp_join.join_type == JoinType::SEMI || - comp_join.join_type == JoinType::ANTI) { - break; - } // FIXME for now, we only push into the projection map for equality (hash) joins // FIXME: add projection to LHS as well bool has_equality = false; @@ -93,7 +89,7 @@ void ColumnLifetimeAnalyzer::VisitOperator(LogicalOperator &op) { LogicalOperatorVisitor::VisitOperatorExpressions(op); column_binding_set_t unused_bindings; - auto old_op_bindings = op.GetColumnBindings(); + auto old_bindings = op.GetColumnBindings(); ExtractUnusedColumnBindings(op.children[1]->GetColumnBindings(), unused_bindings); // now recurse into the filter and its children @@ -101,6 +97,7 @@ void ColumnLifetimeAnalyzer::VisitOperator(LogicalOperator &op) { // then generate the projection map GenerateProjectionMap(op.children[1]->GetColumnBindings(), unused_bindings, comp_join.right_projection_map); + auto new_bindings = op.GetColumnBindings(); return; } case LogicalOperatorType::LOGICAL_UNION: diff --git a/src/optimizer/join_order/cardinality_estimator.cpp b/src/optimizer/join_order/cardinality_estimator.cpp index 4745b00addd..b2767786199 100644 --- a/src/optimizer/join_order/cardinality_estimator.cpp +++ b/src/optimizer/join_order/cardinality_estimator.cpp @@ -1,9 +1,7 @@ #include "duckdb/function/table/table_scan.hpp" #include "duckdb/optimizer/join_order/join_node.hpp" -#include "duckdb/optimizer/join_order/join_order_optimizer.hpp" -#include "duckdb/planner/filter/conjunction_filter.hpp" #include "duckdb/planner/operator/logical_comparison_join.hpp" -#include "duckdb/planner/operator/logical_get.hpp" +#include "duckdb/optimizer/join_order/query_graph_manager.hpp" #include "duckdb/storage/data_table.hpp" #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp" #include "duckdb/common/printer.hpp" @@ -37,7 +35,7 @@ void CardinalityEstimator::AddRelationTdom(FilterInfo &filter_info) { relations_to_tdoms.emplace_back(new_r2tdom); } -bool CardinalityEstimator::SingleRelationFilter(FilterInfo &filter_info) { +bool CardinalityEstimator::SingleColumnFilter(duckdb::FilterInfo &filter_info) { if (filter_info.left_set && filter_info.right_set && filter_info.set.count > 1) { // Both set and are from different relations return false; @@ -48,7 +46,7 @@ bool CardinalityEstimator::SingleRelationFilter(FilterInfo &filter_info) { return true; } -vector CardinalityEstimator::DetermineMatchingEquivalentSets(FilterInfo *filter_info) { +vector CardinalityEstimator::DetermineMatchingEquivalentSets(optional_ptr filter_info) { vector matching_equivalent_sets; idx_t equivalent_relation_index = 0; @@ -66,7 +64,8 @@ vector CardinalityEstimator::DetermineMatchingEquivalentSets(FilterInfo * return matching_equivalent_sets; } -void CardinalityEstimator::AddToEquivalenceSets(FilterInfo *filter_info, vector matching_equivalent_sets) { +void CardinalityEstimator::AddToEquivalenceSets(optional_ptr filter_info, + vector matching_equivalent_sets) { D_ASSERT(matching_equivalent_sets.size() <= 2); if (matching_equivalent_sets.size() > 1) { // an equivalence relation is connecting two sets of equivalence relations @@ -100,8 +99,8 @@ void CardinalityEstimator::InitEquivalentRelations(const vector::iterator subgraph, - vector::iterator end) { - for (; subgraph != end; subgraph++) { - if (subgraph->relations.count(find_me) >= 1) { - for (auto &relation : subgraph->relations) { - merge_to.relations.insert(relation); +bool EdgeConnects(FilterInfoWithTotalDomains &edge, Subgraph2Denominator &subgraph) { + if (edge.filter_info->left_set) { + if (JoinRelationSet::IsSubset(*subgraph.relations, *edge.filter_info->left_set)) { + // cool + return true; + } + } + if (edge.filter_info->right_set) { + if (JoinRelationSet::IsSubset(*subgraph.relations, *edge.filter_info->right_set)) { + return true; + } + } + return false; +} + +vector GetEdges(vector &relations_to_tdom, + JoinRelationSet &requested_set) { + vector res; + for (auto &relation_2_tdom : relations_to_tdom) { + for (auto &filter : relation_2_tdom.filters) { + if (JoinRelationSet::IsSubset(requested_set, filter->set)) { + FilterInfoWithTotalDomains new_edge(filter, relation_2_tdom); + res.push_back(new_edge); } - subgraph->relations.clear(); - merge_to.denom *= subgraph->denom; - return; } } + return res; } -template <> -double CardinalityEstimator::EstimateCardinalityWithSet(JoinRelationSet &new_set) { +vector SubgraphsConnectedByEdge(FilterInfoWithTotalDomains &edge, vector &subgraphs) { + vector res; + if (subgraphs.empty()) { + return res; + } else { + // check the combinations of subgraphs and see if the edge connects two of them, + // if so, return the indexes of the two subgraphs within the vector + for (idx_t outer = 0; outer != subgraphs.size(); outer++) { + // check if the edge connects two subgraphs. + for (idx_t inner = outer + 1; inner != subgraphs.size(); inner++) { + if (EdgeConnects(edge, subgraphs.at(outer)) && EdgeConnects(edge, subgraphs.at(inner))) { + // order is important because we will delete the inner subgraph later + res.push_back(outer); + res.push_back(inner); + return res; + } + } + // if the edge does not connect two subgraphs, see if the edge connects with just outer + // merge subgraph.at(outer) with the RelationSet(s) that edge connects + if (EdgeConnects(edge, subgraphs.at(outer))) { + res.push_back(outer); + return res; + } + } + } + // this edge connects only the relations it connects. Return an empty result so a new subgraph is created. + return res; +} - if (relation_set_2_cardinality.find(new_set.ToString()) != relation_set_2_cardinality.end()) { - return relation_set_2_cardinality[new_set.ToString()].cardinality_before_filters; +JoinRelationSet &CardinalityEstimator::UpdateNumeratorRelations(Subgraph2Denominator left, Subgraph2Denominator right, + FilterInfoWithTotalDomains &filter) { + switch (filter.filter_info->join_type) { + case JoinType::SEMI: + case JoinType::ANTI: { + if (JoinRelationSet::IsSubset(*left.relations, *filter.filter_info->left_set) && + JoinRelationSet::IsSubset(*right.relations, *filter.filter_info->right_set)) { + return *left.numerator_relations; + } + return *right.numerator_relations; } - double numerator = 1; - unordered_set actual_set; + default: + // cross product or inner join + return set_manager.Union(*left.numerator_relations, *right.numerator_relations); + } +} - for (idx_t i = 0; i < new_set.count; i++) { - auto &single_node_set = set_manager.GetJoinRelation(new_set.relations[i]); - auto card_helper = relation_set_2_cardinality[single_node_set.ToString()]; - numerator *= card_helper.cardinality_before_filters == 0 ? 1 : card_helper.cardinality_before_filters; - actual_set.insert(new_set.relations[i]); +double CardinalityEstimator::CalculateUpdatedDenom(Subgraph2Denominator left, Subgraph2Denominator right, + FilterInfoWithTotalDomains &filter) { + double new_denom = left.denom * right.denom; + switch (filter.filter_info->join_type) { + case JoinType::INNER: { + new_denom *= filter.has_tdom_hll ? (double)filter.tdom_hll : (double)filter.tdom_no_hll; + return new_denom; } + case JoinType::SEMI: + case JoinType::ANTI: { + if (JoinRelationSet::IsSubset(*left.relations, *filter.filter_info->left_set) && + JoinRelationSet::IsSubset(*right.relations, *filter.filter_info->right_set)) { + new_denom = left.denom * CardinalityEstimator::DEFAULT_SEMI_ANTI_SELECTIVITY; + return new_denom; + } + new_denom = right.denom * CardinalityEstimator::DEFAULT_SEMI_ANTI_SELECTIVITY; + return new_denom; + } + default: + // cross product + return new_denom; + } +} +DenomInfo CardinalityEstimator::GetDenominator(JoinRelationSet &set) { vector subgraphs; - bool done = false; - bool found_match = false; // Finding the denominator is tricky. You need to go through the tdoms in decreasing order // Then loop through all filters in the equivalence set of the tdom to see if both the @@ -170,87 +242,104 @@ double CardinalityEstimator::EstimateCardinalityWithSet(JoinRelationSet &new_set // TODO: Implement a method to cache subgraphs so you don't have to build them up every // time the cardinality of a new set is requested - // relations_to_tdoms has already been sorted. - for (auto &relation_2_tdom : relations_to_tdoms) { - // loop through each filter in the tdom. - if (done) { - break; - } - for (auto &filter : relation_2_tdom.filters) { - if (actual_set.count(filter->left_binding.table_index) == 0 || - actual_set.count(filter->right_binding.table_index) == 0) { - continue; + // relations_to_tdoms has already been sorted by largest to smallest total domain + // then we look through the filters for the relations_to_tdoms, + // and we start to choose the filters that join relations in the set. + + // edges are guaranteed to be in order of largest tdom to smallest tdom. + auto edges = GetEdges(relations_to_tdoms, set); + for (auto &edge : edges) { + auto subgraph_connections = SubgraphsConnectedByEdge(edge, subgraphs); + + if (subgraph_connections.empty()) { + // create a subgraph out of left and right, then merge right into left and add left to subgraphs. + // this helps cover a case where there are no subgraphs yet, and the only join filter is a SEMI JOIN + auto left_subgraph = Subgraph2Denominator(); + auto right_subgraph = Subgraph2Denominator(); + left_subgraph.relations = edge.filter_info->left_set; + left_subgraph.numerator_relations = edge.filter_info->left_set; + right_subgraph.relations = edge.filter_info->right_set; + right_subgraph.numerator_relations = edge.filter_info->right_set; + + left_subgraph.numerator_relations = &UpdateNumeratorRelations(left_subgraph, right_subgraph, edge); + left_subgraph.relations = &edge.filter_info->set; + left_subgraph.denom = CalculateUpdatedDenom(left_subgraph, right_subgraph, edge); + subgraphs.push_back(left_subgraph); + } else if (subgraph_connections.size() == 1) { + auto left_subgraph = &subgraphs.at(subgraph_connections.at(0)); + auto right_subgraph = Subgraph2Denominator(); + right_subgraph.relations = edge.filter_info->right_set; + right_subgraph.numerator_relations = edge.filter_info->right_set; + if (JoinRelationSet::IsSubset(*left_subgraph->relations, *right_subgraph.relations)) { + right_subgraph.relations = edge.filter_info->left_set; + right_subgraph.numerator_relations = edge.filter_info->left_set; } - // the join filter is on relations in the new set. - found_match = false; - vector::iterator it; - for (it = subgraphs.begin(); it != subgraphs.end(); it++) { - auto left_in = it->relations.count(filter->left_binding.table_index); - auto right_in = it->relations.count(filter->right_binding.table_index); - if (left_in && right_in) { - // if both left and right bindings are in the subgraph, continue. - // This means another filter is connecting relations already in the - // subgraph it, but it has a tdom that is less, and we don't care. - found_match = true; - continue; - } - if (!left_in && !right_in) { - // if both left and right bindings are *not* in the subgraph, continue - // without finding a match. This will trigger the process to add a new - // subgraph - continue; - } - idx_t find_table; - if (left_in) { - find_table = filter->right_binding.table_index; - } else { - D_ASSERT(right_in); - find_table = filter->left_binding.table_index; - } - auto next_subgraph = it + 1; - // iterate through other subgraphs and merge. - FindSubgraphMatchAndMerge(*it, find_table, next_subgraph, subgraphs.end()); - // Now insert the right binding and update denominator with the - // tdom of the filter - it->relations.insert(find_table); - UpdateDenom(*it, relation_2_tdom); - found_match = true; - break; - } - // means that the filter joins relations in the given set, but there is no - // connection to any subgraph in subgraphs. Add a new subgraph, and maybe later there will be - // a connection. - if (!found_match) { - subgraphs.emplace_back(); - auto &subgraph = subgraphs.back(); - subgraph.relations.insert(filter->left_binding.table_index); - subgraph.relations.insert(filter->right_binding.table_index); - UpdateDenom(subgraph, relation_2_tdom); + + if (JoinRelationSet::IsSubset(*left_subgraph->relations, *edge.filter_info->left_set) && + JoinRelationSet::IsSubset(*left_subgraph->relations, *edge.filter_info->right_set)) { + // here we have an edge that connects the same subgraph to the same subgraph. Just continue. no need to + // update the denom + continue; } + left_subgraph->numerator_relations = &UpdateNumeratorRelations(*left_subgraph, right_subgraph, edge); + left_subgraph->relations = &set_manager.Union(*left_subgraph->relations, *right_subgraph.relations); + left_subgraph->denom = CalculateUpdatedDenom(*left_subgraph, right_subgraph, edge); + } else if (subgraph_connections.size() == 2) { + // The two subgraphs in the subgraph_connections can be merged by this edge. + D_ASSERT(subgraph_connections.at(0) < subgraph_connections.at(1)); + auto subgraph_to_merge_into = &subgraphs.at(subgraph_connections.at(0)); + auto subgraph_to_delete = &subgraphs.at(subgraph_connections.at(1)); + subgraph_to_merge_into->relations = + &set_manager.Union(*subgraph_to_merge_into->relations, *subgraph_to_delete->relations); + subgraph_to_merge_into->numerator_relations = + &UpdateNumeratorRelations(*subgraph_to_merge_into, *subgraph_to_delete, edge); + subgraph_to_delete->relations = nullptr; + subgraph_to_merge_into->denom = CalculateUpdatedDenom(*subgraph_to_merge_into, *subgraph_to_delete, edge); auto remove_start = std::remove_if(subgraphs.begin(), subgraphs.end(), - [](Subgraph2Denominator &s) { return s.relations.empty(); }); + [](Subgraph2Denominator &s) { return !s.relations; }); subgraphs.erase(remove_start, subgraphs.end()); + } + if (subgraphs.size() == 1 && subgraphs.at(0).relations->ToString() == set.ToString()) { + // the first subgraph has connected all the desired relations, no need to iterate + // through the rest of the edges. + break; + } + } - if (subgraphs.size() == 1 && subgraphs.at(0).relations.size() == new_set.count) { - // You have found enough filters to connect the relations. These are guaranteed - // to be the filters with the highest Tdoms. - done = true; - break; - } + // It's possible cross-products were added and are not present in the filters in the relation_2_tdom + // structures. When that's the case, merge all remaining subgraphs. + if (subgraphs.size() > 1) { + auto final_subgraph = subgraphs.at(0); + for (auto merge_with = subgraphs.begin() + 1; merge_with != subgraphs.end(); merge_with++) { + D_ASSERT(final_subgraph.relations && merge_with->relations); + final_subgraph.relations = &set_manager.Union(*final_subgraph.relations, *merge_with->relations); + D_ASSERT(final_subgraph.numerator_relations && merge_with->numerator_relations); + final_subgraph.numerator_relations = + &set_manager.Union(*final_subgraph.numerator_relations, *merge_with->numerator_relations); + final_subgraph.denom *= merge_with->denom; } } - double denom = 1; - // TODO: It's possible cross-products were added and are not present in the filters in the relation_2_tdom - // structures. When that's the case, multiply the denom structures that have no intersection - for (auto &match : subgraphs) { - denom *= match.denom; + // can happen if a table has cardinality 0, a tdom is set to 0, or if a cross product is used. + if (subgraphs.empty() || subgraphs.at(0).denom == 0) { + // denominator is 1 and numerators are a cross product of cardinalities. + return DenomInfo(set, 1, 1); } - // can happen if a table has cardinality 0, or a tdom is set to 0 - if (denom <= 1) { - denom = 1; + return DenomInfo(*subgraphs.at(0).numerator_relations, 1, subgraphs.at(0).denom); +} + +template <> +double CardinalityEstimator::EstimateCardinalityWithSet(JoinRelationSet &new_set) { + + if (relation_set_2_cardinality.find(new_set.ToString()) != relation_set_2_cardinality.end()) { + return relation_set_2_cardinality[new_set.ToString()].cardinality_before_filters; } - auto result = numerator / denom; - auto new_entry = CardinalityHelper((double)result, 1); + + // can happen if a table has cardinality 0, or a tdom is set to 0 + auto denom = GetDenominator(new_set); + auto numerator = GetNumerator(denom.numerator_relations); + + double result = numerator / denom.denominator; + auto new_entry = CardinalityHelper(result); relation_set_2_cardinality[new_set.ToString()] = new_entry; return result; } @@ -259,7 +348,7 @@ template <> idx_t CardinalityEstimator::EstimateCardinalityWithSet(JoinRelationSet &new_set) { auto cardinality_as_double = EstimateCardinalityWithSet(new_set); auto max = NumericLimits::Maximum(); - if (cardinality_as_double >= max) { + if (cardinality_as_double >= (double)max) { return max; } return (idx_t)cardinality_as_double; @@ -282,9 +371,8 @@ void CardinalityEstimator::InitCardinalityEstimatorProps(optional_ptrToString()] = card_helper; UpdateTotalDomains(set, stats); diff --git a/src/optimizer/join_order/join_relation_set.cpp b/src/optimizer/join_order/join_relation_set.cpp index d08ac4c89bb..aa5767427ae 100644 --- a/src/optimizer/join_order/join_relation_set.cpp +++ b/src/optimizer/join_order/join_relation_set.cpp @@ -99,11 +99,15 @@ JoinRelationSet &JoinRelationSetManager::Union(JoinRelationSet &left, JoinRelati // left is smaller, progress left and add it to the set relations[count++] = left.relations[i]; i++; - } else { - D_ASSERT(left.relations[i] > right.relations[j]); + } else if (left.relations[i] > right.relations[j]) { // right is smaller, progress right and add it to the set relations[count++] = right.relations[j]; j++; + } else { + D_ASSERT(left.relations[i] == right.relations[j]); + relations[count++] = left.relations[i]; + i++; + j++; } } return GetJoinRelation(std::move(relations), count); diff --git a/src/optimizer/join_order/plan_enumerator.cpp b/src/optimizer/join_order/plan_enumerator.cpp index 712a6c42922..a5e618fc677 100644 --- a/src/optimizer/join_order/plan_enumerator.cpp +++ b/src/optimizer/join_order/plan_enumerator.cpp @@ -104,12 +104,24 @@ unique_ptr PlanEnumerator::CreateJoinTree(JoinRelationSet &set, // FIXME: we should probably actually benchmark that as well // FIXME: should consider different join algorithms, should we pick a join algorithm here as well? (probably) optional_ptr best_connection = nullptr; - - // cross products are techincally still connections, but the filter expression is a null_ptr + // cross products are technically still connections, but the filter expression is a null_ptr if (!possible_connections.empty()) { best_connection = &possible_connections.back().get(); } + auto join_type = JoinType::INVALID; + for (auto &filter_binding : best_connection->filters) { + if (!filter_binding->left_set || !filter_binding->right_set) { + continue; + } + join_type = filter_binding->join_type; + // prefer joining on semi and anti joins as they have a higher chance of being more + // selective + if (join_type == JoinType::SEMI || join_type == JoinType::ANTI) { + break; + } + } + // need the filter info from the Neighborhood info. auto cost = cost_model.ComputeCost(left, right); auto result = make_uniq(set, best_connection, left.set, right.set, cost); result->cardinality = cost_model.cardinality_estimator.EstimateCardinalityWithSet(set); diff --git a/src/optimizer/join_order/query_graph_manager.cpp b/src/optimizer/join_order/query_graph_manager.cpp index 004dd551bda..446a3ad610d 100644 --- a/src/optimizer/join_order/query_graph_manager.cpp +++ b/src/optimizer/join_order/query_graph_manager.cpp @@ -193,7 +193,15 @@ GenerateJoinRelation QueryGraphManager::GenerateJoins(vector(JoinType::INNER); + auto chosen_filter = node->info->filters.at(0); + for (idx_t i = 0; i < node->info->filters.size(); i++) { + if (node->info->filters.at(i)->join_type == JoinType::INNER) { + chosen_filter = node->info->filters.at(i); + break; + } + } + + auto join = make_uniq(chosen_filter->join_type); // Here we optimize build side probe side. Our build side is the right side // So the right plans should have lower cardinalities. join->children.push_back(std::move(left.op)); @@ -216,7 +224,14 @@ GenerateJoinRelation QueryGraphManager::GenerateJoins(vectorCast(); // we need to figure out which side is which by looking at the relations available to us + // left/right (build side/probe side) optimizations happen later. bool invert = !JoinRelationSet::IsSubset(*left.set, *f->left_set); + // If the left and right set are inverted AND it is a semi or anti join + // swap left and right children back. + if (invert && (f->join_type == JoinType::SEMI || f->join_type == JoinType::ANTI)) { + std::swap(left, right); + invert = false; + } cond.left = !invert ? std::move(comparison.left) : std::move(comparison.right); cond.right = !invert ? std::move(comparison.right) : std::move(comparison.left); cond.comparison = condition->type; diff --git a/src/optimizer/join_order/relation_manager.cpp b/src/optimizer/join_order/relation_manager.cpp index 3df21b77e7f..29710d7c1d3 100644 --- a/src/optimizer/join_order/relation_manager.cpp +++ b/src/optimizer/join_order/relation_manager.cpp @@ -9,8 +9,6 @@ #include "duckdb/planner/expression/list.hpp" #include "duckdb/planner/operator/list.hpp" -#include - namespace duckdb { const vector RelationManager::GetRelationStats() { @@ -102,6 +100,23 @@ static bool OperatorIsNonReorderable(LogicalOperatorType op_type) { } } +static bool JoinIsReorderable(LogicalOperator &op) { + if (op.type == LogicalOperatorType::LOGICAL_CROSS_PRODUCT) { + return true; + } else if (op.type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) { + auto &join = op.Cast(); + switch (join.join_type) { + case JoinType::INNER: + case JoinType::SEMI: + case JoinType::ANTI: + return true; + default: + return false; + } + } + return false; +} + static bool HasNonReorderableChild(LogicalOperator &op) { LogicalOperator *tmp = &op; while (tmp->children.size() == 1) { @@ -110,8 +125,7 @@ static bool HasNonReorderableChild(LogicalOperator &op) { } tmp = tmp->children[0].get(); if (tmp->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) { - auto &join = tmp->Cast(); - if (join.join_type != JoinType::INNER) { + if (!JoinIsReorderable(*tmp)) { return true; } } @@ -141,8 +155,7 @@ bool RelationManager::ExtractJoinRelations(LogicalOperator &input_op, } if (op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) { - auto &join = op->Cast(); - if (join.join_type == JoinType::INNER) { + if (JoinIsReorderable(*op)) { // extract join conditions from inner join filter_operators.push_back(*op); } else { @@ -314,7 +327,6 @@ vector> RelationManager::ExtractEdges(LogicalOperator &op if (f_op.type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN || f_op.type == LogicalOperatorType::LOGICAL_ASOF_JOIN) { auto &join = f_op.Cast(); - D_ASSERT(join.join_type == JoinType::INNER); D_ASSERT(join.expressions.empty()); for (auto &cond : join.conditions) { auto comparison = @@ -324,7 +336,8 @@ vector> RelationManager::ExtractEdges(LogicalOperator &op unordered_set bindings; ExtractBindings(*comparison, bindings); auto &set = set_manager.GetJoinRelation(bindings); - auto filter_info = make_uniq(std::move(comparison), set, filters_and_bindings.size()); + auto filter_info = + make_uniq(std::move(comparison), set, filters_and_bindings.size(), join.join_type); filters_and_bindings.push_back(std::move(filter_info)); } } diff --git a/src/optimizer/join_order/relation_statistics_helper.cpp b/src/optimizer/join_order/relation_statistics_helper.cpp index 79af3bd8ca3..5432d004f9a 100644 --- a/src/optimizer/join_order/relation_statistics_helper.cpp +++ b/src/optimizer/join_order/relation_statistics_helper.cpp @@ -59,10 +59,10 @@ RelationStats RelationStatisticsHelper::ExtractGetStats(LogicalGet &get, ClientC auto cardinality_after_filters = base_table_cardinality; unique_ptr column_statistics; - auto table_thing = get.GetTable(); + auto catalog_table = get.GetTable(); auto name = string("some table"); - if (table_thing) { - name = table_thing->name; + if (catalog_table) { + name = catalog_table->name; return_stats.table_name = name; } @@ -82,7 +82,8 @@ RelationStats RelationStatisticsHelper::ExtractGetStats(LogicalGet &get, ClientC if (get.function.statistics) { column_statistics = get.function.statistics(context, get.bind_data.get(), get.column_ids[i]); if (column_statistics && have_catalog_table_statistics) { - auto column_distinct_count = DistinctCount({column_statistics->GetDistinctCount(), true}); + auto distinct_count = MaxValue((idx_t)1, column_statistics->GetDistinctCount()); + auto column_distinct_count = DistinctCount({distinct_count, true}); return_stats.column_distinct_count.push_back(column_distinct_count); return_stats.column_names.push_back(name + "." + get.names.at(get.column_ids.at(i))); have_distinct_count_stats = true; @@ -105,9 +106,8 @@ RelationStats RelationStatisticsHelper::ExtractGetStats(LogicalGet &get, ClientC if (!get.table_filters.filters.empty()) { column_statistics = nullptr; for (auto &it : get.table_filters.filters) { - if (get.bind_data && get.function.name.compare("seq_scan") == 0) { - auto &table_scan_bind_data = get.bind_data->Cast(); - column_statistics = get.function.statistics(context, &table_scan_bind_data, it.first); + if (get.bind_data && get.function.statistics) { + column_statistics = get.function.statistics(context, get.bind_data.get(), it.first); } if (column_statistics && it.second->filter_type == TableFilterType::CONJUNCTION_AND) { diff --git a/src/optimizer/statistics/operator/propagate_filter.cpp b/src/optimizer/statistics/operator/propagate_filter.cpp index 6bd1d30c160..7dbdc6da75b 100644 --- a/src/optimizer/statistics/operator/propagate_filter.cpp +++ b/src/optimizer/statistics/operator/propagate_filter.cpp @@ -241,7 +241,12 @@ unique_ptr StatisticsPropagator::PropagateStatistics(LogicalFilt filter.expressions.erase_at(i); i--; if (filter.expressions.empty()) { - // just break. The physical filter planner will plan a projection instead + // if there is a projection map, we should keep the filter + // the physical planner will eventually skip the filter, but will keep + // the correct columns. + if (filter.projection_map.empty()) { + node_ptr = std::move(filter.children[0]); + } break; } } else if (ExpressionIsConstant(*condition, Value::BOOLEAN(false)) || diff --git a/src/parser/expression/function_expression.cpp b/src/parser/expression/function_expression.cpp index 1658d0a39e2..8cd5d4c7056 100644 --- a/src/parser/expression/function_expression.cpp +++ b/src/parser/expression/function_expression.cpp @@ -95,4 +95,18 @@ void FunctionExpression::Verify() const { D_ASSERT(!function_name.empty()); } +bool FunctionExpression::IsLambdaFunction() const { + // Ignore the ->> operator (JSON extension). + if (function_name == "->>") { + return false; + } + // Check the children for lambda expressions. + for (auto &child : children) { + if (child->expression_class == ExpressionClass::LAMBDA) { + return true; + } + } + return false; +} + } // namespace duckdb diff --git a/src/parser/parsed_data/transaction_info.cpp b/src/parser/parsed_data/transaction_info.cpp index 8e1aeb6755f..af102e6e34c 100644 --- a/src/parser/parsed_data/transaction_info.cpp +++ b/src/parser/parsed_data/transaction_info.cpp @@ -6,7 +6,8 @@ namespace duckdb { TransactionInfo::TransactionInfo() : ParseInfo(TYPE) { } -TransactionInfo::TransactionInfo(TransactionType type) : ParseInfo(TYPE), type(type) { +TransactionInfo::TransactionInfo(TransactionType type) + : ParseInfo(TYPE), type(type), modifier(TransactionModifierType::TRANSACTION_DEFAULT_MODIFIER) { } string TransactionInfo::ToString() const { @@ -26,8 +27,27 @@ string TransactionInfo::ToString() const { EnumUtil::ToString(type)); } } + switch (modifier) { + case TransactionModifierType::TRANSACTION_DEFAULT_MODIFIER: + break; + case TransactionModifierType::TRANSACTION_READ_ONLY: + result += " READ ONLY"; + break; + case TransactionModifierType::TRANSACTION_READ_WRITE: + result += " READ WRITE"; + break; + default: + throw InternalException("ToString for TransactionStatement with modifier type: %s not implemented", + EnumUtil::ToString(modifier)); + } result += ";"; return result; } +unique_ptr TransactionInfo::Copy() const { + auto result = make_uniq(type); + result->modifier = modifier; + return result; +} + } // namespace duckdb diff --git a/src/parser/parser.cpp b/src/parser/parser.cpp index 7dd7a43d9f6..65ee319704d 100644 --- a/src/parser/parser.cpp +++ b/src/parser/parser.cpp @@ -1,5 +1,6 @@ #include "duckdb/parser/parser.hpp" +#include "duckdb/parser/group_by_node.hpp" #include "duckdb/parser/parsed_data/create_table_info.hpp" #include "duckdb/parser/parser_extension.hpp" #include "duckdb/parser/query_error_context.hpp" @@ -8,7 +9,6 @@ #include "duckdb/parser/statement/extension_statement.hpp" #include "duckdb/parser/statement/select_statement.hpp" #include "duckdb/parser/statement/update_statement.hpp" -#include "duckdb/parser/group_by_node.hpp" #include "duckdb/parser/tableref/expressionlistref.hpp" #include "duckdb/parser/transformer.hpp" #include "parser/parser.hpp" @@ -42,6 +42,16 @@ static bool ReplaceUnicodeSpaces(const string &query, string &new_query, vector< return true; } +static bool IsValidDollarQuotedStringTagFirstChar(const unsigned char &c) { + // the first character can be between A-Z, a-z, or \200 - \377 + return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c >= 0x80; +} + +static bool IsValidDollarQuotedStringTagSubsequentChar(const unsigned char &c) { + // subsequent characters can also be between 0-9 + return IsValidDollarQuotedStringTagFirstChar(c) || (c >= '0' && c <= '9'); +} + // This function strips unicode space characters from the query and replaces them with regular spaces // It returns true if any unicode space characters were found and stripped // See here for a list of unicode space characters - https://jkorpela.fi/chars/spaces.html @@ -50,6 +60,7 @@ bool Parser::StripUnicodeSpaces(const string &query_str, string &new_query) { const idx_t USP_LEN = 3; idx_t pos = 0; unsigned char quote; + string_t dollar_quote_tag; vector unicode_spaces; auto query = const_uchar_ptr_cast(query_str.c_str()); auto qsize = query_str.size(); @@ -95,6 +106,24 @@ bool Parser::StripUnicodeSpaces(const string &query_str, string &new_query) { quote = query[pos]; pos++; goto in_quotes; + } else if (query[pos] == '$' && + (query[pos + 1] == '$' || IsValidDollarQuotedStringTagFirstChar(query[pos + 1]))) { + // (optionally tagged) dollar-quoted string + auto start = &query[++pos]; + for (; pos + 2 < qsize; pos++) { + if (query[pos] == '$') { + // end of tag + dollar_quote_tag = + string_t(const_char_ptr_cast(start), NumericCast(&query[pos] - start)); + goto in_dollar_quotes; + } + + if (!IsValidDollarQuotedStringTagSubsequentChar(query[pos])) { + // invalid char in dollar-quoted string, continue as normal + goto regular; + } + } + goto end; } else if (query[pos] == '-' && query[pos + 1] == '-') { goto in_comment; } @@ -113,6 +142,17 @@ bool Parser::StripUnicodeSpaces(const string &query_str, string &new_query) { } } goto end; +in_dollar_quotes: + for (; pos + 2 < qsize; pos++) { + if (query[pos] == '$' && + qsize - (pos + 1) >= dollar_quote_tag.GetSize() + 1 && // found '$' and enough space left + query[pos + dollar_quote_tag.GetSize() + 1] == '$' && // ending '$' at the right spot + memcmp(&query[pos + 1], dollar_quote_tag.GetData(), dollar_quote_tag.GetSize()) == 0) { // tags match + pos += dollar_quote_tag.GetSize() + 1; + goto regular; + } + } + goto end; in_comment: for (; pos < qsize; pos++) { if (query[pos] == '\n' || query[pos] == '\r') { diff --git a/src/parser/statement/transaction_statement.cpp b/src/parser/statement/transaction_statement.cpp index 9ff14825bb2..f1098536bb5 100644 --- a/src/parser/statement/transaction_statement.cpp +++ b/src/parser/statement/transaction_statement.cpp @@ -2,12 +2,12 @@ namespace duckdb { -TransactionStatement::TransactionStatement(TransactionType type) - : SQLStatement(StatementType::TRANSACTION_STATEMENT), info(make_uniq(type)) { +TransactionStatement::TransactionStatement(unique_ptr info) + : SQLStatement(StatementType::TRANSACTION_STATEMENT), info(std::move(info)) { } TransactionStatement::TransactionStatement(const TransactionStatement &other) - : SQLStatement(other), info(make_uniq(other.info->type)) { + : SQLStatement(other), info(other.info->Copy()) { } unique_ptr TransactionStatement::Copy() const { diff --git a/src/parser/transform/constraint/transform_constraint.cpp b/src/parser/transform/constraint/transform_constraint.cpp index ef601ac47f2..dcb467e9cd1 100644 --- a/src/parser/transform/constraint/transform_constraint.cpp +++ b/src/parser/transform/constraint/transform_constraint.cpp @@ -5,16 +5,12 @@ namespace duckdb { -static void ParseSchemaTableNameFK(duckdb_libpgquery::PGRangeVar *input, ForeignKeyInfo &fk_info) { - if (input->catalogname) { +static void ParseSchemaTableNameFK(duckdb_libpgquery::PGRangeVar &input, ForeignKeyInfo &fk_info) { + if (input.catalogname) { throw ParserException("FOREIGN KEY constraints cannot be defined cross-database"); } - if (input->schemaname) { - fk_info.schema = input->schemaname; - } else { - fk_info.schema = ""; - }; - fk_info.table = input->relname; + fk_info.schema = input.schemaname ? input.schemaname : ""; + fk_info.table = input.relname; } static bool ForeignKeyActionSupported(char action) { @@ -33,28 +29,34 @@ static bool ForeignKeyActionSupported(char action) { } static unique_ptr -TransformForeignKeyConstraint(duckdb_libpgquery::PGConstraint *constraint, +TransformForeignKeyConstraint(duckdb_libpgquery::PGConstraint &constraint, optional_ptr override_fk_column = nullptr) { - D_ASSERT(constraint); - if (!ForeignKeyActionSupported(constraint->fk_upd_action) || - !ForeignKeyActionSupported(constraint->fk_del_action)) { + if (!ForeignKeyActionSupported(constraint.fk_upd_action) || !ForeignKeyActionSupported(constraint.fk_del_action)) { throw ParserException("FOREIGN KEY constraints cannot use CASCADE, SET NULL or SET DEFAULT"); } + ForeignKeyInfo fk_info; fk_info.type = ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE; - ParseSchemaTableNameFK(constraint->pktable, fk_info); - vector pk_columns, fk_columns; + ParseSchemaTableNameFK(*constraint.pktable, fk_info); + + vector pk_columns; + vector fk_columns; + if (override_fk_column) { - D_ASSERT(!constraint->fk_attrs); + D_ASSERT(!constraint.fk_attrs); fk_columns.emplace_back(*override_fk_column); - } else if (constraint->fk_attrs) { - for (auto kc = constraint->fk_attrs->head; kc; kc = kc->next) { - fk_columns.emplace_back(reinterpret_cast(kc->data.ptr_value)->val.str); + + } else if (constraint.fk_attrs) { + for (auto kc = constraint.fk_attrs->head; kc; kc = kc->next) { + auto value = Transformer::PGPointerCast(kc->data.ptr_value); + fk_columns.emplace_back(value->val.str); } } - if (constraint->pk_attrs) { - for (auto kc = constraint->pk_attrs->head; kc; kc = kc->next) { - pk_columns.emplace_back(reinterpret_cast(kc->data.ptr_value)->val.str); + + if (constraint.pk_attrs) { + for (auto kc = constraint.pk_attrs->head; kc; kc = kc->next) { + auto value = Transformer::PGPointerCast(kc->data.ptr_value); + pk_columns.emplace_back(value->val.str); } } if (!pk_columns.empty() && pk_columns.size() != fk_columns.size()) { @@ -66,9 +68,11 @@ TransformForeignKeyConstraint(duckdb_libpgquery::PGConstraint *constraint, return make_uniq(pk_columns, fk_columns, std::move(fk_info)); } -unique_ptr Transformer::TransformConstraint(duckdb_libpgquery::PGListCell *cell) { - auto constraint = reinterpret_cast(cell->data.ptr_value); +unique_ptr Transformer::TransformConstraint(duckdb_libpgquery::PGListCell &cell) { + + auto constraint = PGPointerCast(cell.data.ptr_value); D_ASSERT(constraint); + switch (constraint->contype) { case duckdb_libpgquery::PG_CONSTR_UNIQUE: case duckdb_libpgquery::PG_CONSTR_PRIMARY: { @@ -78,7 +82,8 @@ unique_ptr Transformer::TransformConstraint(duckdb_libpgquery::PGLis } vector columns; for (auto kc = constraint->keys->head; kc; kc = kc->next) { - columns.emplace_back(reinterpret_cast(kc->data.ptr_value)->val.str); + auto value = PGPointerCast(kc->data.ptr_value); + columns.emplace_back(value->val.str); } return make_uniq(columns, is_primary_key); } @@ -90,17 +95,18 @@ unique_ptr Transformer::TransformConstraint(duckdb_libpgquery::PGLis return make_uniq(TransformExpression(constraint->raw_expr)); } case duckdb_libpgquery::PG_CONSTR_FOREIGN: - return TransformForeignKeyConstraint(constraint); - + return TransformForeignKeyConstraint(*constraint.get()); default: throw NotImplementedException("Constraint type not handled yet!"); } } -unique_ptr Transformer::TransformConstraint(duckdb_libpgquery::PGListCell *cell, ColumnDefinition &column, +unique_ptr Transformer::TransformConstraint(duckdb_libpgquery::PGListCell &cell, ColumnDefinition &column, idx_t index) { - auto constraint = reinterpret_cast(cell->data.ptr_value); + + auto constraint = PGPointerCast(cell.data.ptr_value); D_ASSERT(constraint); + switch (constraint->contype) { case duckdb_libpgquery::PG_CONSTR_NOTNULL: return make_uniq(LogicalIndex(index)); @@ -133,7 +139,7 @@ unique_ptr Transformer::TransformConstraint(duckdb_libpgquery::PGLis } return nullptr; case duckdb_libpgquery::PG_CONSTR_FOREIGN: - return TransformForeignKeyConstraint(constraint, &column.Name()); + return TransformForeignKeyConstraint(*constraint.get(), &column.Name()); default: throw NotImplementedException("Constraint not implemented!"); } diff --git a/src/parser/transform/helpers/transform_alias.cpp b/src/parser/transform/helpers/transform_alias.cpp index 637e94a5aac..5f0ef56e9c4 100644 --- a/src/parser/transform/helpers/transform_alias.cpp +++ b/src/parser/transform/helpers/transform_alias.cpp @@ -8,7 +8,8 @@ vector Transformer::TransformStringList(duckdb_libpgquery::PGList *list) return result; } for (auto node = list->head; node != nullptr; node = node->next) { - result.emplace_back(reinterpret_cast(node->data.ptr_value)->val.str); + auto value = PGPointerCast(node->data.ptr_value); + result.emplace_back(value->val.str); } return result; } diff --git a/src/parser/transform/helpers/transform_cte.cpp b/src/parser/transform/helpers/transform_cte.cpp index c4678bdd98f..a481dac2483 100644 --- a/src/parser/transform/helpers/transform_cte.cpp +++ b/src/parser/transform/helpers/transform_cte.cpp @@ -42,8 +42,8 @@ void Transformer::TransformCTE(duckdb_libpgquery::PGWithClause &de_with_clause, auto &cte = *PGPointerCast(cte_ele->data.ptr_value); if (cte.aliascolnames) { for (auto node = cte.aliascolnames->head; node != nullptr; node = node->next) { - info->aliases.emplace_back( - reinterpret_cast(node->data.ptr_value)->val.str); + auto value = PGPointerCast(node->data.ptr_value); + info->aliases.emplace_back(value->val.str); } } // lets throw some errors on unsupported features early diff --git a/src/parser/transform/helpers/transform_orderby.cpp b/src/parser/transform/helpers/transform_orderby.cpp index d448e11400e..0feec0eadc0 100644 --- a/src/parser/transform/helpers/transform_orderby.cpp +++ b/src/parser/transform/helpers/transform_orderby.cpp @@ -1,7 +1,7 @@ #include "duckdb/parser/expression/constant_expression.hpp" +#include "duckdb/parser/expression/star_expression.hpp" #include "duckdb/parser/statement/select_statement.hpp" #include "duckdb/parser/transformer.hpp" -#include "duckdb/parser/expression/star_expression.hpp" namespace duckdb { @@ -11,35 +11,38 @@ bool Transformer::TransformOrderBy(duckdb_libpgquery::PGList *order, vectorhead; node != nullptr; node = node->next) { - auto temp = reinterpret_cast(node->data.ptr_value); - if (temp->type == duckdb_libpgquery::T_PGSortBy) { - OrderType type; - OrderByNullType null_order; - auto sort = reinterpret_cast(temp); - auto target = sort->node; - if (sort->sortby_dir == duckdb_libpgquery::PG_SORTBY_DEFAULT) { - type = OrderType::ORDER_DEFAULT; - } else if (sort->sortby_dir == duckdb_libpgquery::PG_SORTBY_ASC) { - type = OrderType::ASCENDING; - } else if (sort->sortby_dir == duckdb_libpgquery::PG_SORTBY_DESC) { - type = OrderType::DESCENDING; - } else { - throw NotImplementedException("Unimplemented order by type"); - } - if (sort->sortby_nulls == duckdb_libpgquery::PG_SORTBY_NULLS_DEFAULT) { - null_order = OrderByNullType::ORDER_DEFAULT; - } else if (sort->sortby_nulls == duckdb_libpgquery::PG_SORTBY_NULLS_FIRST) { - null_order = OrderByNullType::NULLS_FIRST; - } else if (sort->sortby_nulls == duckdb_libpgquery::PG_SORTBY_NULLS_LAST) { - null_order = OrderByNullType::NULLS_LAST; - } else { - throw NotImplementedException("Unimplemented order by type"); - } - auto order_expression = TransformExpression(target); - result.emplace_back(type, null_order, std::move(order_expression)); + auto temp_node = PGPointerCast(node->data.ptr_value); + if (temp_node->type != duckdb_libpgquery::T_PGSortBy) { + throw NotImplementedException("ORDER BY list member type %d\n", temp_node->type); + } + + OrderType type; + OrderByNullType null_order; + auto sort = PGCast(*temp_node.get()); + auto target = sort.node; + + if (sort.sortby_dir == duckdb_libpgquery::PG_SORTBY_DEFAULT) { + type = OrderType::ORDER_DEFAULT; + } else if (sort.sortby_dir == duckdb_libpgquery::PG_SORTBY_ASC) { + type = OrderType::ASCENDING; + } else if (sort.sortby_dir == duckdb_libpgquery::PG_SORTBY_DESC) { + type = OrderType::DESCENDING; } else { - throw NotImplementedException("ORDER BY list member type %d\n", temp->type); + throw NotImplementedException("Unimplemented order by type"); } + + if (sort.sortby_nulls == duckdb_libpgquery::PG_SORTBY_NULLS_DEFAULT) { + null_order = OrderByNullType::ORDER_DEFAULT; + } else if (sort.sortby_nulls == duckdb_libpgquery::PG_SORTBY_NULLS_FIRST) { + null_order = OrderByNullType::NULLS_FIRST; + } else if (sort.sortby_nulls == duckdb_libpgquery::PG_SORTBY_NULLS_LAST) { + null_order = OrderByNullType::NULLS_LAST; + } else { + throw NotImplementedException("Unimplemented order by type"); + } + + auto order_expression = TransformExpression(target); + result.emplace_back(type, null_order, std::move(order_expression)); } return true; } diff --git a/src/parser/transform/statement/transform_alter_table.cpp b/src/parser/transform/statement/transform_alter_table.cpp index cd2fc7fc406..d3b57c8e2e4 100644 --- a/src/parser/transform/statement/transform_alter_table.cpp +++ b/src/parser/transform/statement/transform_alter_table.cpp @@ -11,47 +11,47 @@ OnEntryNotFound Transformer::TransformOnEntryNotFound(bool missing_ok) { } unique_ptr Transformer::TransformAlter(duckdb_libpgquery::PGAlterTableStmt &stmt) { - D_ASSERT(stmt.relation); + D_ASSERT(stmt.relation); if (stmt.cmds->length != 1) { throw ParserException("Only one ALTER command per statement is supported"); } auto result = make_uniq(); - auto qname = TransformQualifiedName(*stmt.relation); + auto qualified_name = TransformQualifiedName(*stmt.relation); - // first we check the type of ALTER + // Check the ALTER type. for (auto c = stmt.cmds->head; c != nullptr; c = c->next) { - auto command = reinterpret_cast(lfirst(c)); - AlterEntryData data(qname.catalog, qname.schema, qname.name, TransformOnEntryNotFound(stmt.missing_ok)); - // TODO: Include more options for command->subtype + + auto command = PGPointerCast(c->data.ptr_value); + AlterEntryData data(qualified_name.catalog, qualified_name.schema, qualified_name.name, + TransformOnEntryNotFound(stmt.missing_ok)); + switch (command->subtype) { case duckdb_libpgquery::PG_AT_AddColumn: { - auto cdef = PGPointerCast(command->def); - + auto column_def = PGPointerCast(command->def); if (stmt.relkind != duckdb_libpgquery::PG_OBJECT_TABLE) { throw ParserException("Adding columns is only supported for tables"); } - if (cdef->category == duckdb_libpgquery::COL_GENERATED) { + if (column_def->category == duckdb_libpgquery::COL_GENERATED) { throw ParserException("Adding generated columns after table creation is not supported yet"); } - auto centry = TransformColumnDefinition(*cdef); - if (cdef->constraints) { - for (auto constr = cdef->constraints->head; constr != nullptr; constr = constr->next) { - auto constraint = TransformConstraint(constr, centry, 0); + auto column_entry = TransformColumnDefinition(*column_def); + if (column_def->constraints) { + for (auto constr = column_def->constraints->head; constr != nullptr; constr = constr->next) { + auto constraint = TransformConstraint(*constr, column_entry, 0); if (!constraint) { continue; } throw ParserException("Adding columns with constraints not yet supported"); } } - result->info = make_uniq(std::move(data), std::move(centry), command->missing_ok); + result->info = make_uniq(std::move(data), std::move(column_entry), command->missing_ok); break; } case duckdb_libpgquery::PG_AT_DropColumn: { - bool cascade = command->behavior == duckdb_libpgquery::PG_DROP_CASCADE; - + auto cascade = command->behavior == duckdb_libpgquery::PG_DROP_CASCADE; if (stmt.relkind != duckdb_libpgquery::PG_OBJECT_TABLE) { throw ParserException("Dropping columns is only supported for tables"); } @@ -60,7 +60,6 @@ unique_ptr Transformer::TransformAlter(duckdb_libpgquery::PGAlte } case duckdb_libpgquery::PG_AT_ColumnDefault: { auto expr = TransformExpression(command->def); - if (stmt.relkind != duckdb_libpgquery::PG_OBJECT_TABLE) { throw ParserException("Alter column's default is only supported for tables"); } @@ -68,21 +67,21 @@ unique_ptr Transformer::TransformAlter(duckdb_libpgquery::PGAlte break; } case duckdb_libpgquery::PG_AT_AlterColumnType: { - auto cdef = PGPointerCast(command->def); - auto column_definition = TransformColumnDefinition(*cdef); - unique_ptr expr; + auto column_def = PGPointerCast(command->def); + auto column_entry = TransformColumnDefinition(*column_def); + unique_ptr expr; if (stmt.relkind != duckdb_libpgquery::PG_OBJECT_TABLE) { throw ParserException("Alter column's type is only supported for tables"); } - if (cdef->raw_default) { - expr = TransformExpression(cdef->raw_default); + if (column_def->raw_default) { + expr = TransformExpression(column_def->raw_default); } else { - auto colref = make_uniq(command->name); - expr = make_uniq(column_definition.Type(), std::move(colref)); + auto col_ref = make_uniq(command->name); + expr = make_uniq(column_entry.Type(), std::move(col_ref)); } - result->info = make_uniq(std::move(data), command->name, column_definition.Type(), - std::move(expr)); + result->info = + make_uniq(std::move(data), command->name, column_entry.Type(), std::move(expr)); break; } case duckdb_libpgquery::PG_AT_SetNotNull: { @@ -98,7 +97,6 @@ unique_ptr Transformer::TransformAlter(duckdb_libpgquery::PGAlte throw NotImplementedException("No support for that ALTER TABLE option yet!"); } } - return result; } diff --git a/src/parser/transform/statement/transform_create_table.cpp b/src/parser/transform/statement/transform_create_table.cpp index f1ac88eb71a..e0177e4fac8 100644 --- a/src/parser/transform/statement/transform_create_table.cpp +++ b/src/parser/transform/statement/transform_create_table.cpp @@ -1,9 +1,9 @@ -#include "duckdb/parser/statement/create_statement.hpp" -#include "duckdb/parser/parsed_data/create_table_info.hpp" -#include "duckdb/parser/transformer.hpp" +#include "duckdb/catalog/catalog_entry/table_column_type.hpp" #include "duckdb/parser/constraint.hpp" #include "duckdb/parser/expression/collate_expression.hpp" -#include "duckdb/catalog/catalog_entry/table_column_type.hpp" +#include "duckdb/parser/parsed_data/create_table_info.hpp" +#include "duckdb/parser/statement/create_statement.hpp" +#include "duckdb/parser/transformer.hpp" namespace duckdb { @@ -101,7 +101,7 @@ unique_ptr Transformer::TransformCreateTable(duckdb_libpgquery: auto centry = TransformColumnDefinition(*cdef); if (cdef->constraints) { for (auto constr = cdef->constraints->head; constr != nullptr; constr = constr->next) { - auto constraint = TransformConstraint(constr, centry, info->columns.LogicalColumnCount()); + auto constraint = TransformConstraint(*constr, centry, info->columns.LogicalColumnCount()); if (constraint) { info->constraints.push_back(std::move(constraint)); } @@ -112,7 +112,7 @@ unique_ptr Transformer::TransformCreateTable(duckdb_libpgquery: break; } case duckdb_libpgquery::T_PGConstraint: { - info->constraints.push_back(TransformConstraint(c)); + info->constraints.push_back(TransformConstraint(*c)); break; } default: diff --git a/src/parser/transform/statement/transform_transaction.cpp b/src/parser/transform/statement/transform_transaction.cpp index e35bf9ac17f..ba4c04527ae 100644 --- a/src/parser/transform/statement/transform_transaction.cpp +++ b/src/parser/transform/statement/transform_transaction.cpp @@ -3,18 +3,39 @@ namespace duckdb { -unique_ptr Transformer::TransformTransaction(duckdb_libpgquery::PGTransactionStmt &stmt) { - switch (stmt.kind) { +TransactionType TransformTransactionType(duckdb_libpgquery::PGTransactionStmtKind kind) { + switch (kind) { case duckdb_libpgquery::PG_TRANS_STMT_BEGIN: case duckdb_libpgquery::PG_TRANS_STMT_START: - return make_uniq(TransactionType::BEGIN_TRANSACTION); + return TransactionType::BEGIN_TRANSACTION; case duckdb_libpgquery::PG_TRANS_STMT_COMMIT: - return make_uniq(TransactionType::COMMIT); + return TransactionType::COMMIT; case duckdb_libpgquery::PG_TRANS_STMT_ROLLBACK: - return make_uniq(TransactionType::ROLLBACK); + return TransactionType::ROLLBACK; + default: + throw NotImplementedException("Transaction type %d not implemented yet", kind); + } +} + +TransactionModifierType TransformTransactionModifier(duckdb_libpgquery::PGTransactionStmtType type) { + switch (type) { + case duckdb_libpgquery::PG_TRANS_TYPE_DEFAULT: + return TransactionModifierType::TRANSACTION_DEFAULT_MODIFIER; + case duckdb_libpgquery::PG_TRANS_TYPE_READ_ONLY: + return TransactionModifierType::TRANSACTION_READ_ONLY; + case duckdb_libpgquery::PG_TRANS_TYPE_READ_WRITE: + return TransactionModifierType::TRANSACTION_READ_WRITE; default: - throw NotImplementedException("Transaction type %d not implemented yet", stmt.kind); + throw NotImplementedException("Transaction modifier %d not implemented yet", type); } } +unique_ptr Transformer::TransformTransaction(duckdb_libpgquery::PGTransactionStmt &stmt) { + // stmt.transaction_type + auto type = TransformTransactionType(stmt.kind); + auto info = make_uniq(type); + info->modifier = TransformTransactionModifier(stmt.transaction_type); + return make_uniq(std::move(info)); +} + } // namespace duckdb diff --git a/src/parser/transform/statement/transform_update.cpp b/src/parser/transform/statement/transform_update.cpp index 5de966571ea..9f5951d02c4 100644 --- a/src/parser/transform/statement/transform_update.cpp +++ b/src/parser/transform/statement/transform_update.cpp @@ -1,5 +1,5 @@ -#include "duckdb/parser/statement/update_statement.hpp" #include "duckdb/parser/statement/update_extensions_statement.hpp" +#include "duckdb/parser/statement/update_statement.hpp" #include "duckdb/parser/transformer.hpp" namespace duckdb { @@ -7,13 +7,14 @@ namespace duckdb { unique_ptr Transformer::TransformUpdateSetInfo(duckdb_libpgquery::PGList *target_list, duckdb_libpgquery::PGNode *where_clause) { auto result = make_uniq(); - auto root = target_list; + for (auto cell = root->head; cell != nullptr; cell = cell->next) { auto target = PGPointerCast(cell->data.ptr_value); result->columns.emplace_back(target->name); result->expressions.push_back(TransformExpression(target->val)); } + result->condition = TransformExpression(where_clause); return result; } @@ -21,21 +22,20 @@ unique_ptr Transformer::TransformUpdateSetInfo(duckdb_libpgquery: unique_ptr Transformer::TransformUpdate(duckdb_libpgquery::PGUpdateStmt &stmt) { auto result = make_uniq(); if (stmt.withClause) { - TransformCTE(*PGPointerCast(stmt.withClause), result->cte_map); + auto with_clause = PGPointerCast(stmt.withClause); + TransformCTE(*with_clause, result->cte_map); } result->table = TransformRangeVar(*stmt.relation); if (stmt.fromClause) { result->from_table = TransformFrom(stmt.fromClause); } - result->set_info = TransformUpdateSetInfo(stmt.targetList, stmt.whereClause); // Grab and transform the returning columns from the parser. if (stmt.returningList) { TransformExpressionList(*stmt.returningList, result->returning_list); } - return result; } @@ -46,14 +46,13 @@ Transformer::TransformUpdateExtensions(duckdb_libpgquery::PGUpdateExtensionsStmt if (stmt.extensions) { auto column_list = PGPointerCast(stmt.extensions); - for (auto c = column_list->head; c != nullptr; c = lnext(c)) { - auto extension = reinterpret_cast(c->data.ptr_value)->val.str; - info->extensions_to_update.emplace_back(extension); + for (auto c = column_list->head; c != nullptr; c = c->next) { + auto value = PGPointerCast(c->data.ptr_value); + info->extensions_to_update.emplace_back(value->val.str); } } result->info = std::move(info); - return result; } diff --git a/src/parser/transform/statement/transform_upsert.cpp b/src/parser/transform/statement/transform_upsert.cpp index 3c550cb083b..aa0130f3c82 100644 --- a/src/parser/transform/statement/transform_upsert.cpp +++ b/src/parser/transform/statement/transform_upsert.cpp @@ -1,5 +1,4 @@ #include "duckdb/parser/statement/insert_statement.hpp" -#include "duckdb/parser/statement/update_statement.hpp" #include "duckdb/parser/tableref/expressionlistref.hpp" #include "duckdb/parser/transformer.hpp" @@ -67,23 +66,23 @@ unique_ptr Transformer::DummyOnConflictClause(duckdb_libpgquery: } unique_ptr Transformer::TransformOnConflictClause(duckdb_libpgquery::PGOnConflictClause *node, - const string &relname) { - auto stmt = reinterpret_cast(node); + const string &) { + + auto stmt = PGPointerCast(node); D_ASSERT(stmt); auto result = make_uniq(); - result->action_type = TransformOnConflictAction(stmt); + result->action_type = TransformOnConflictAction(stmt.get()); + if (stmt->infer) { - // A filter for the ON CONFLICT ... is specified - if (stmt->infer->indexElems) { - // Columns are specified - result->indexed_columns = TransformConflictTarget(*stmt->infer->indexElems); - if (stmt->infer->whereClause) { - result->condition = TransformExpression(stmt->infer->whereClause); - } - } else { + // A filter for the ON CONFLICT ... is specified. + if (!stmt->infer->indexElems) { throw NotImplementedException("ON CONSTRAINT conflict target is not supported yet"); } + result->indexed_columns = TransformConflictTarget(*stmt->infer->indexElems); + if (stmt->infer->whereClause) { + result->condition = TransformExpression(stmt->infer->whereClause); + } } if (result->action_type == OnConflictAction::UPDATE) { diff --git a/src/parser/transform/statement/transform_vacuum.cpp b/src/parser/transform/statement/transform_vacuum.cpp index c61934cca7c..e18dedad134 100644 --- a/src/parser/transform/statement/transform_vacuum.cpp +++ b/src/parser/transform/statement/transform_vacuum.cpp @@ -3,7 +3,7 @@ namespace duckdb { -VacuumOptions ParseOptions(int options) { +VacuumOptions ParseOptions(const int32_t options) { VacuumOptions result; if (options & duckdb_libpgquery::PGVacuumOption::PG_VACOPT_VACUUM) { result.vacuum = true; @@ -43,8 +43,8 @@ unique_ptr Transformer::TransformVacuum(duckdb_libpgquery::PGVacuu if (stmt.va_cols) { D_ASSERT(result->info->has_table); for (auto col_node = stmt.va_cols->head; col_node != nullptr; col_node = col_node->next) { - result->info->columns.emplace_back( - reinterpret_cast(col_node->data.ptr_value)->val.str); + auto value = PGPointerCast(col_node->data.ptr_value); + result->info->columns.emplace_back(value->val.str); } } return std::move(result); diff --git a/src/parser/transform/tableref/transform_join.cpp b/src/parser/transform/tableref/transform_join.cpp index 9c60ec244b4..5aa6637ea78 100644 --- a/src/parser/transform/tableref/transform_join.cpp +++ b/src/parser/transform/tableref/transform_join.cpp @@ -39,14 +39,14 @@ unique_ptr Transformer::TransformJoin(duckdb_libpgquery::PGJoinExpr &r result->ref_type = JoinRefType::POSITIONAL; break; } - default: { + default: throw NotImplementedException("Join type %d not supported\n", root.jointype); } - } - // Check the type of left arg and right arg before transform + // Check the type of the left and right argument before transforming. result->left = TransformTableRefNode(*root.larg); result->right = TransformTableRefNode(*root.rarg); + switch (root.joinreftype) { case duckdb_libpgquery::PG_JOIN_NATURAL: result->ref_type = JoinRefType::NATURAL; @@ -57,32 +57,38 @@ unique_ptr Transformer::TransformJoin(duckdb_libpgquery::PGJoinExpr &r default: break; } + SetQueryLocation(*result, root.location); if (root.usingClause && root.usingClause->length > 0) { - // usingClause is a list of strings + // usingClause is a list of strings. for (auto node = root.usingClause->head; node != nullptr; node = node->next) { - auto target = reinterpret_cast(node->data.ptr_value); + auto target = PGPointerCast(node->data.ptr_value); D_ASSERT(target->type == duckdb_libpgquery::T_PGString); - auto column_name = string(reinterpret_cast(target)->val.str); - result->using_columns.push_back(column_name); + auto value = PGCast(*target.get()); + result->using_columns.push_back(string(value.val.str)); } return std::move(result); } - if (!root.quals && result->using_columns.empty() && result->ref_type == JoinRefType::REGULAR) { // CROSS PRODUCT + // Check if this is a cross product. + if (!root.quals && result->using_columns.empty() && result->ref_type == JoinRefType::REGULAR) { result->ref_type = JoinRefType::CROSS; } result->condition = TransformExpression(root.quals); + if (root.alias) { - // join with an alias - wrap it in a subquery + // This is a join with an alias, so we 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 + + // Apply the alias to the subquery. subquery->alias = TransformAlias(root.alias, subquery->column_name_alias); return std::move(subquery); } diff --git a/src/planner/binder.cpp b/src/planner/binder.cpp index e59a33106cc..d564604dde7 100644 --- a/src/planner/binder.cpp +++ b/src/planner/binder.cpp @@ -516,11 +516,28 @@ void Binder::AddTableName(string table_name) { root_binder.table_names.insert(std::move(table_name)); } +void Binder::AddReplacementScan(const string &table_name, unique_ptr replacement) { + auto &root_binder = GetRootBinder(); + auto it = root_binder.replacement_scans.find(table_name); + replacement->column_name_alias.clear(); + replacement->alias.clear(); + if (it == root_binder.replacement_scans.end()) { + root_binder.replacement_scans[table_name] = std::move(replacement); + } else { + // A replacement scan by this name was previously registered, we can just use it + } +} + const unordered_set &Binder::GetTableNames() { auto &root_binder = GetRootBinder(); return root_binder.table_names; } +case_insensitive_map_t> &Binder::GetReplacementScans() { + auto &root_binder = GetRootBinder(); + return root_binder.replacement_scans; +} + // FIXME: this is extremely naive void VerifyNotExcluded(ParsedExpression &expr) { if (expr.type == ExpressionType::COLUMN_REF) { diff --git a/src/planner/binder/expression/bind_columnref_expression.cpp b/src/planner/binder/expression/bind_columnref_expression.cpp index ce6cb104b72..94d92670441 100644 --- a/src/planner/binder/expression/bind_columnref_expression.cpp +++ b/src/planner/binder/expression/bind_columnref_expression.cpp @@ -155,10 +155,9 @@ void ExpressionBinder::QualifyColumnNames(unique_ptr &expr, break; } case ExpressionType::FUNCTION: { - // special-handling for lambdas, which are inside function expressions, + // Special-handling for lambdas, which are inside function expressions. auto &function = expr->Cast(); - if (IsLambdaFunction(function)) { - // special case + if (function.IsLambdaFunction()) { return QualifyColumnNamesInLambda(function, lambda_params); } diff --git a/src/planner/binder/expression/bind_function_expression.cpp b/src/planner/binder/expression/bind_function_expression.cpp index 8eb9a890459..f1f137a834d 100644 --- a/src/planner/binder/expression/bind_function_expression.cpp +++ b/src/planner/binder/expression/bind_function_expression.cpp @@ -87,9 +87,7 @@ BindResult ExpressionBinder::BindExpression(FunctionExpression &function, idx_t switch (func->type) { case CatalogType::SCALAR_FUNCTION_ENTRY: { - // scalar function - if (IsLambdaFunction(function)) { - // special case + if (function.IsLambdaFunction()) { return TryBindLambdaOrJson(function, depth, *func); } return BindFunction(function, func->Cast(), depth); diff --git a/src/planner/binder/expression/bind_macro_expression.cpp b/src/planner/binder/expression/bind_macro_expression.cpp index ced09d18028..d35d9a57973 100644 --- a/src/planner/binder/expression/bind_macro_expression.cpp +++ b/src/planner/binder/expression/bind_macro_expression.cpp @@ -14,19 +14,18 @@ void ExpressionBinder::ReplaceMacroParametersInLambda(FunctionExpression &functi for (auto &child : function.children) { if (child->expression_class != ExpressionClass::LAMBDA) { - // not a lambda expression ReplaceMacroParameters(child, lambda_params); continue; } - // special-handling for LHS lambda parameters - // we do not replace them, and we add them to the lambda_params vector + // Special-handling for LHS lambda parameters. + // We do not replace them, and we add them to the lambda_params vector. auto &lambda_expr = child->Cast(); string error_message; auto column_ref_expressions = lambda_expr.ExtractColumnRefExpressions(error_message); if (!error_message.empty()) { - // possibly a JSON function, replace both LHS and RHS + // Possibly a JSON function, replace both LHS and RHS. ParsedExpressionIterator::EnumerateChildren(*lambda_expr.lhs, [&](unique_ptr &child) { ReplaceMacroParameters(child, lambda_params); }); @@ -36,21 +35,18 @@ void ExpressionBinder::ReplaceMacroParametersInLambda(FunctionExpression &functi continue; } - // push this level + // Push the lambda parameter names of this level. lambda_params.emplace_back(); - - // push the lambda parameter names for (const auto &column_ref_expr : column_ref_expressions) { const auto &column_ref = column_ref_expr.get().Cast(); lambda_params.back().emplace(column_ref.GetName()); } - // only replace in RHS + // Only replace in the RHS of the expression. ParsedExpressionIterator::EnumerateChildren(*lambda_expr.expr, [&](unique_ptr &child) { ReplaceMacroParameters(child, lambda_params); }); - // pop this level lambda_params.pop_back(); } } @@ -60,10 +56,8 @@ void ExpressionBinder::ReplaceMacroParameters(unique_ptr &expr switch (expr->GetExpressionClass()) { case ExpressionClass::COLUMN_REF: { - // if the expression is a parameter, replace it with its argument + // If the expression is a column reference, we replace it with its argument. auto &col_ref = expr->Cast(); - - // don't replace lambda parameters if (LambdaExpression::IsLambdaParameter(lambda_params, col_ref.GetName())) { return; } @@ -84,10 +78,9 @@ void ExpressionBinder::ReplaceMacroParameters(unique_ptr &expr return; } case ExpressionClass::FUNCTION: { - // special-handling for lambdas, which are inside function expressions, + // Special-handling for lambdas, which are inside function expressions. auto &function = expr->Cast(); - if (IsLambdaFunction(function)) { - // special case + if (function.IsLambdaFunction()) { return ReplaceMacroParametersInLambda(function, lambda_params); } break; @@ -98,11 +91,10 @@ void ExpressionBinder::ReplaceMacroParameters(unique_ptr &expr *sq->node, [&](unique_ptr &child) { ReplaceMacroParameters(child, lambda_params); }); break; } - default: // fall through + default: break; } - // replace macro parameters in child expressions ParsedExpressionIterator::EnumerateChildren( *expr, [&](unique_ptr &child) { ReplaceMacroParameters(child, lambda_params); }); } diff --git a/src/planner/binder/statement/bind_copy.cpp b/src/planner/binder/statement/bind_copy.cpp index e3d9cd39780..d709240de4f 100644 --- a/src/planner/binder/statement/bind_copy.cpp +++ b/src/planner/binder/statement/bind_copy.cpp @@ -33,9 +33,6 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) { if (!config.options.enable_external_access) { throw PermissionException("COPY TO is disabled by configuration"); } - BoundStatement result; - result.types = {LogicalType::BIGINT}; - result.names = {"Count"}; // lookup the format in the catalog auto ©_function = @@ -62,6 +59,8 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) { optional_idx file_size_bytes; vector partition_cols; bool seen_overwrite_mode = false; + bool seen_filepattern = false; + CopyFunctionReturnType return_type = CopyFunctionReturnType::CHANGED_ROWS; CopyFunctionBindInput bind_input(*stmt.info); @@ -74,9 +73,9 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) { if (loption == "use_tmp_file") { use_tmp_file = GetBooleanArg(context, option.second); user_set_use_tmp_file = true; - } else if (loption == "overwrite_or_ignore" || loption == "overwrite") { + } else if (loption == "overwrite_or_ignore" || loption == "overwrite" || loption == "append") { if (seen_overwrite_mode) { - throw BinderException("Can only set one of OVERWRITE_OR_IGNORE or OVERWRITE"); + throw BinderException("Can only set one of OVERWRITE_OR_IGNORE, OVERWRITE or APPEND"); } seen_overwrite_mode = true; @@ -86,6 +85,11 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) { overwrite_mode = CopyOverwriteMode::COPY_OVERWRITE_OR_IGNORE; } else if (loption == "overwrite") { overwrite_mode = CopyOverwriteMode::COPY_OVERWRITE; + } else if (loption == "append") { + if (!seen_filepattern) { + filename_pattern.SetFilenamePattern("{uuid}"); + } + overwrite_mode = CopyOverwriteMode::COPY_APPEND; } } } else if (loption == "filename_pattern") { @@ -94,6 +98,7 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) { } filename_pattern.SetFilenamePattern( option.second[0].CastAs(context, LogicalType::VARCHAR).GetValue()); + seen_filepattern = true; } else if (loption == "file_extension") { if (option.second.empty()) { throw IOException("FILE_EXTENSION cannot be empty"); @@ -116,6 +121,10 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) { } else if (loption == "partition_by") { auto converted = ConvertVectorToValue(std::move(option.second)); partition_cols = ParseColumnsOrdered(converted, select_node.names, loption); + } else if (loption == "return_files") { + if (GetBooleanArg(context, option.second)) { + return_type = CopyFunctionReturnType::CHANGED_ROWS_AND_FILE_LIST; + } } else { if (loption == "compression") { if (option.second.empty()) { @@ -135,6 +144,9 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) { stmt.info->options[option.first] = option.second; } } + if (overwrite_mode == CopyOverwriteMode::COPY_APPEND && !filename_pattern.HasUUID()) { + throw BinderException("APPEND mode requires a {uuid} label in filename_pattern"); + } if (user_set_use_tmp_file && per_thread_output) { throw NotImplementedException("Can't combine USE_TMP_FILE and PER_THREAD_OUTPUT for COPY"); } @@ -199,12 +211,28 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) { copy->rotate = rotate; copy->partition_output = !partition_cols.empty(); copy->partition_columns = std::move(partition_cols); + copy->return_type = return_type; copy->names = unique_column_names; copy->expected_types = select_node.types; copy->AddChild(std::move(select_node.plan)); + auto &properties = GetStatementProperties(); + switch (copy->return_type) { + case CopyFunctionReturnType::CHANGED_ROWS: + properties.return_type = StatementReturnType::CHANGED_ROWS; + break; + case CopyFunctionReturnType::CHANGED_ROWS_AND_FILE_LIST: + properties.return_type = StatementReturnType::QUERY_RESULT; + break; + default: + throw NotImplementedException("Unknown CopyFunctionReturnType"); + } + + BoundStatement result; + result.names = GetCopyFunctionReturnNames(copy->return_type); + result.types = GetCopyFunctionReturnLogicalTypes(copy->return_type); result.plan = std::move(copy); return result; diff --git a/src/planner/binder/statement/bind_insert.cpp b/src/planner/binder/statement/bind_insert.cpp index a979da57c64..ec565c56ac1 100644 --- a/src/planner/binder/statement/bind_insert.cpp +++ b/src/planner/binder/statement/bind_insert.cpp @@ -1,5 +1,6 @@ #include "duckdb/catalog/catalog.hpp" #include "duckdb/parser/expression/constant_expression.hpp" +#include "duckdb/parser/expression/function_expression.hpp" #include "duckdb/parser/statement/insert_statement.hpp" #include "duckdb/parser/query_node/select_node.hpp" #include "duckdb/parser/tableref/expressionlistref.hpp" @@ -12,13 +13,10 @@ #include "duckdb/planner/operator/logical_dummy_scan.hpp" #include "duckdb/planner/operator/logical_projection.hpp" #include "duckdb/planner/expression_iterator.hpp" -#include "duckdb/planner/expression_binder/returning_binder.hpp" #include "duckdb/planner/expression_binder/where_binder.hpp" #include "duckdb/planner/expression_binder/update_binder.hpp" -#include "duckdb/planner/operator/logical_filter.hpp" #include "duckdb/parser/statement/update_statement.hpp" #include "duckdb/planner/expression/bound_default_expression.hpp" -#include "duckdb/storage/data_table.hpp" #include "duckdb/catalog/catalog_entry/index_catalog_entry.hpp" #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp" #include "duckdb/planner/bound_tableref.hpp" @@ -54,18 +52,85 @@ void ReplaceDefaultExpression(unique_ptr &expr, const ColumnDe expr = ExpandDefaultExpression(column); } -void QualifyColumnReferences(unique_ptr &expr, const string &table_name) { - // To avoid ambiguity with 'excluded', we explicitly qualify all column references - if (expr->type == ExpressionType::COLUMN_REF) { - auto &column_ref = expr->Cast(); - if (column_ref.IsQualified()) { +void ExpressionBinder::DoUpdateSetQualifyInLambda(FunctionExpression &function, const string &table_name, + vector> &lambda_params) { + + for (auto &child : function.children) { + if (child->expression_class != ExpressionClass::LAMBDA) { + DoUpdateSetQualify(child, table_name, lambda_params); + continue; + } + + // Special-handling for LHS lambda parameters. + // We do not qualify them, and we add them to the lambda_params vector. + auto &lambda_expr = child->Cast(); + string error_message; + auto column_ref_expressions = lambda_expr.ExtractColumnRefExpressions(error_message); + + if (!error_message.empty()) { + // Possibly a JSON function, qualify both LHS and RHS. + ParsedExpressionIterator::EnumerateChildren(*lambda_expr.lhs, [&](unique_ptr &child) { + DoUpdateSetQualify(child, table_name, lambda_params); + }); + ParsedExpressionIterator::EnumerateChildren(*lambda_expr.expr, [&](unique_ptr &child) { + DoUpdateSetQualify(child, table_name, lambda_params); + }); + continue; + } + + // Push the lambda parameter names of this level. + lambda_params.emplace_back(); + for (const auto &column_ref_expr : column_ref_expressions) { + const auto &column_ref = column_ref_expr.get().Cast(); + lambda_params.back().emplace(column_ref.GetName()); + } + + // Only qualify in the RHS of the expression. + ParsedExpressionIterator::EnumerateChildren(*lambda_expr.expr, [&](unique_ptr &child) { + DoUpdateSetQualify(child, table_name, lambda_params); + }); + + lambda_params.pop_back(); + } +} + +void ExpressionBinder::DoUpdateSetQualify(unique_ptr &expr, const string &table_name, + vector> &lambda_params) { + + // We avoid ambiguity with EXCLUDED columns by qualifying all column references. + switch (expr->GetExpressionClass()) { + case ExpressionClass::COLUMN_REF: { + auto &col_ref = expr->Cast(); + if (col_ref.IsQualified()) { + return; + } + + // Don't qualify lambda parameters. + if (LambdaExpression::IsLambdaParameter(lambda_params, col_ref.GetName())) { return; } - auto column_name = column_ref.GetColumnName(); - expr = make_uniq(column_name, table_name); + + // Qualify the column reference. + expr = make_uniq(col_ref.GetColumnName(), table_name); + return; + } + case ExpressionClass::FUNCTION: { + // Special-handling for lambdas, which are inside function expressions. + auto &function = expr->Cast(); + if (function.IsLambdaFunction()) { + return DoUpdateSetQualifyInLambda(function, table_name, lambda_params); + } + break; } + case ExpressionClass::SUBQUERY: { + throw BinderException("DO UPDATE SET clause cannot contain a subquery"); + } + default: + break; + } + ParsedExpressionIterator::EnumerateChildren( - *expr, [&](unique_ptr &child) { QualifyColumnReferences(child, table_name); }); + *expr, [&](unique_ptr &child) { DoUpdateSetQualify(child, table_name, lambda_params); }); } // Replace binding.table_index with 'dest' if it's 'source' @@ -110,18 +175,17 @@ void Binder::BindDoUpdateSetExpressions(const string &table_alias, LogicalInsert if (expr->type == ExpressionType::VALUE_DEFAULT) { expr = ExpandDefaultExpression(column); } - UpdateBinder binder(*this, context); - binder.target_type = column.Type(); - // Avoid ambiguity issues - QualifyColumnReferences(expr, table_alias); + // Qualify and bind the ON CONFLICT DO UPDATE SET expression. + UpdateBinder update_binder(*this, context); + update_binder.target_type = column.Type(); - auto bound_expr = binder.Bind(expr); - D_ASSERT(bound_expr); - if (bound_expr->expression_class == ExpressionClass::BOUND_SUBQUERY) { - throw BinderException("Expression in the DO UPDATE SET clause can not be a subquery"); - } + // Avoid ambiguity between existing table columns and EXCLUDED columns. + vector> lambda_params; + update_binder.DoUpdateSetQualify(expr, table_alias, lambda_params); + auto bound_expr = update_binder.Bind(expr); + D_ASSERT(bound_expr); insert.expressions.push_back(std::move(bound_expr)); } @@ -293,18 +357,17 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl bind_context.AddGenericBinding(excluded_index, "excluded", table_column_names, table_column_types); if (on_conflict.condition) { - // Avoid ambiguity between binding and 'excluded' - QualifyColumnReferences(on_conflict.condition, table_alias); - // Bind the ON CONFLICT ... WHERE clause WhereBinder where_binder(*this, context); + + // Avoid ambiguity between existing table columns and EXCLUDED columns. + vector> lambda_params; + where_binder.DoUpdateSetQualify(on_conflict.condition, table_alias, lambda_params); + + // Bind the ON CONFLICT ... WHERE clause. auto condition = where_binder.Bind(on_conflict.condition); - if (condition && condition->expression_class == ExpressionClass::BOUND_SUBQUERY) { - throw BinderException("conflict_target WHERE clause can not be a subquery"); - } insert.on_conflict_condition = std::move(condition); } - auto bindings = insert.children[0]->GetColumnBindings(); optional_idx projection_index; reference>> insert_child_operators = insert.children; while (!projection_index.IsValid()) { @@ -363,14 +426,14 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl D_ASSERT(set_info.columns.size() == set_info.expressions.size()); if (set_info.condition) { - // Avoid ambiguity between binding and 'excluded' - QualifyColumnReferences(set_info.condition, table_alias); - // Bind the SET ... WHERE clause WhereBinder where_binder(*this, context); + + // Avoid ambiguity between existing table columns and EXCLUDED columns. + vector> lambda_params; + where_binder.DoUpdateSetQualify(set_info.condition, table_alias, lambda_params); + + // Bind the SET ... WHERE clause. auto condition = where_binder.Bind(set_info.condition); - if (condition && condition->expression_class == ExpressionClass::BOUND_SUBQUERY) { - throw BinderException("conflict_target WHERE clause can not be a subquery"); - } insert.do_update_condition = std::move(condition); } @@ -487,7 +550,7 @@ BoundStatement Binder::Bind(InsertStatement &stmt) { expr_list.expected_types.resize(expected_columns); expr_list.expected_names.resize(expected_columns); - D_ASSERT(expr_list.values.size() > 0); + D_ASSERT(!expr_list.values.empty()); CheckInsertColumnCountMismatch(expected_columns, expr_list.values[0].size(), !stmt.columns.empty(), table.name.c_str()); diff --git a/src/planner/binder/tableref/bind_basetableref.cpp b/src/planner/binder/tableref/bind_basetableref.cpp index 88739947b06..5455a53a964 100644 --- a/src/planner/binder/tableref/bind_basetableref.cpp +++ b/src/planner/binder/tableref/bind_basetableref.cpp @@ -1,20 +1,20 @@ #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp" #include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp" +#include "duckdb/common/string_util.hpp" +#include "duckdb/main/client_context.hpp" +#include "duckdb/main/config.hpp" +#include "duckdb/main/extension_helper.hpp" +#include "duckdb/parser/query_node/select_node.hpp" +#include "duckdb/parser/statement/select_statement.hpp" #include "duckdb/parser/tableref/basetableref.hpp" #include "duckdb/parser/tableref/subqueryref.hpp" -#include "duckdb/parser/query_node/select_node.hpp" +#include "duckdb/parser/tableref/table_function_ref.hpp" #include "duckdb/planner/binder.hpp" +#include "duckdb/planner/operator/logical_get.hpp" #include "duckdb/planner/tableref/bound_basetableref.hpp" -#include "duckdb/planner/tableref/bound_subqueryref.hpp" #include "duckdb/planner/tableref/bound_cteref.hpp" -#include "duckdb/planner/operator/logical_get.hpp" -#include "duckdb/parser/statement/select_statement.hpp" -#include "duckdb/common/string_util.hpp" -#include "duckdb/main/extension_helper.hpp" -#include "duckdb/parser/tableref/table_function_ref.hpp" -#include "duckdb/main/config.hpp" #include "duckdb/planner/tableref/bound_dummytableref.hpp" -#include "duckdb/main/client_context.hpp" +#include "duckdb/planner/tableref/bound_subqueryref.hpp" namespace duckdb { @@ -50,7 +50,7 @@ unique_ptr Binder::BindWithReplacementScan(ClientContext &context return nullptr; } for (auto &scan : config.replacement_scans) { - ReplacementScanInput input(ref.Cast(), table_name); + ReplacementScanInput input(table_name); auto replacement_function = scan.function(context, input, scan.data.get()); if (!replacement_function) { continue; @@ -71,6 +71,9 @@ unique_ptr Binder::BindWithReplacementScan(ClientContext &context } else { throw InternalException("Replacement scan should return either a table function or a subquery"); } + if (GetBindingMode() == BindingMode::EXTRACT_REPLACEMENT_SCANS) { + AddReplacementScan(ref.table_name, replacement_function->Copy()); + } return Bind(*replacement_function); } return nullptr; @@ -93,26 +96,8 @@ unique_ptr Binder::Bind(BaseTableRef &ref) { for (auto found_cte : found_ctes) { auto &cte = found_cte.get(); auto ctebinding = bind_context.GetCTEBinding(ref.table_name); - if (!ctebinding) { - if (CTEIsAlreadyBound(cte)) { - // remember error state - circular_cte = true; - // retry with next candidate CTE - continue; - } - // Move CTE to subquery and bind recursively - SubqueryRef subquery(unique_ptr_cast(cte.query->Copy())); - subquery.alias = ref.alias.empty() ? ref.table_name : ref.alias; - subquery.column_name_alias = cte.aliases; - for (idx_t i = 0; i < ref.column_name_alias.size(); i++) { - if (i < subquery.column_name_alias.size()) { - subquery.column_name_alias[i] = ref.column_name_alias[i]; - } else { - subquery.column_name_alias.push_back(ref.column_name_alias[i]); - } - } - return Bind(subquery, &found_cte.get()); - } else { + if (ctebinding && (cte.query->node->type == QueryNodeType::RECURSIVE_CTE_NODE || + cte.materialized == CTEMaterialize::CTE_MATERIALIZE_ALWAYS)) { // There is a CTE binding in the BindContext. // This can only be the case if there is a recursive CTE, // or a materialized CTE present. @@ -137,9 +122,39 @@ unique_ptr Binder::Bind(BaseTableRef &ref) { result->types = ctebinding->types; result->bound_columns = std::move(names); return std::move(result); + } else { + if (CTEIsAlreadyBound(cte)) { + // remember error state + circular_cte = true; + // retry with next candidate CTE + continue; + } + // Move CTE to subquery and bind recursively + SubqueryRef subquery(unique_ptr_cast(cte.query->Copy())); + subquery.alias = ref.alias.empty() ? ref.table_name : ref.alias; + subquery.column_name_alias = cte.aliases; + for (idx_t i = 0; i < ref.column_name_alias.size(); i++) { + if (i < subquery.column_name_alias.size()) { + subquery.column_name_alias[i] = ref.column_name_alias[i]; + } else { + subquery.column_name_alias.push_back(ref.column_name_alias[i]); + } + } + return Bind(subquery, &found_cte.get()); } } if (circular_cte) { + string table_name = ref.catalog_name; + if (!ref.schema_name.empty()) { + table_name += (!table_name.empty() ? "." : "") + ref.schema_name; + } + table_name += (!table_name.empty() ? "." : "") + ref.table_name; + + auto replacement_scan_bind_result = BindWithReplacementScan(context, table_name, ref); + if (replacement_scan_bind_result) { + return replacement_scan_bind_result; + } + throw BinderException( "Circular reference to CTE \"%s\", There are two possible solutions. \n1. use WITH RECURSIVE to " "use recursive CTEs. \n2. If " diff --git a/src/planner/binder/tableref/bind_table_function.cpp b/src/planner/binder/tableref/bind_table_function.cpp index 97445227a40..bbd79ec5985 100644 --- a/src/planner/binder/tableref/bind_table_function.cpp +++ b/src/planner/binder/tableref/bind_table_function.cpp @@ -23,32 +23,71 @@ namespace duckdb { -static bool IsTableInTableOutFunction(TableFunctionCatalogEntry &table_function) { - auto fun = table_function.functions.GetFunctionByOffset(0); - return table_function.functions.Size() == 1 && fun.arguments.size() == 1 && - fun.arguments[0].id() == LogicalTypeId::TABLE; +enum class TableFunctionBindType { STANDARD_TABLE_FUNCTION, TABLE_IN_OUT_FUNCTION, TABLE_PARAMETER_FUNCTION }; + +static TableFunctionBindType GetTableFunctionBindType(TableFunctionCatalogEntry &table_function, + vector> &expressions) { + // first check if all expressions are scalar + // if they are we always bind as a standard table function + bool all_scalar = true; + for (auto &expr : expressions) { + if (!expr->IsScalar()) { + all_scalar = false; + break; + } + } + if (all_scalar) { + return TableFunctionBindType::STANDARD_TABLE_FUNCTION; + } + // if we have non-scalar parameters - we need to look at the function definition to decide how to bind + // if a function does not have an in_out_function defined, we need to bind as a standard table function regardless + bool has_in_out_function = false; + bool has_standard_table_function = false; + bool has_table_parameter = false; + for (idx_t function_idx = 0; function_idx < table_function.functions.Size(); function_idx++) { + const auto &function = table_function.functions.GetFunctionReferenceByOffset(function_idx); + for (auto &arg : function.arguments) { + if (arg.id() == LogicalTypeId::TABLE) { + has_table_parameter = true; + } + } + if (function.in_out_function) { + has_in_out_function = true; + } else if (function.function || function.bind_replace) { + has_standard_table_function = true; + } else { + throw InternalException("Function \"%s\" has neither in_out_function nor function defined", + table_function.name); + } + } + if (has_table_parameter) { + if (table_function.functions.Size() != 1) { + throw InternalException( + "Function \"%s\" has a TABLE parameter, and multiple function overloads - this is not supported", + table_function.name); + } + return TableFunctionBindType::TABLE_PARAMETER_FUNCTION; + } + if (has_in_out_function && has_standard_table_function) { + throw InternalException("Function \"%s\" is both an in_out_function and a table function", table_function.name); + } + return has_in_out_function ? TableFunctionBindType::TABLE_IN_OUT_FUNCTION + : TableFunctionBindType::STANDARD_TABLE_FUNCTION; } -bool Binder::BindTableInTableOutFunction(vector> &expressions, - unique_ptr &subquery, ErrorData &error) { +void Binder::BindTableInTableOutFunction(vector> &expressions, + unique_ptr &subquery) { auto binder = Binder::CreateBinder(this->context, this); unique_ptr subquery_node; - if (expressions.size() == 1 && expressions[0]->type == ExpressionType::SUBQUERY) { - // general case: argument is a subquery, bind it as part of the node - auto &se = expressions[0]->Cast(); - subquery_node = std::move(se.subquery->node); - } else { - // special case: non-subquery parameter to table-in table-out function - // generate a subquery and bind that (i.e. UNNEST([1,2,3]) becomes UNNEST((SELECT [1,2,3])) - auto select_node = make_uniq(); - select_node->select_list = std::move(expressions); - select_node->from_table = make_uniq(); - subquery_node = std::move(select_node); - } + // generate a subquery and bind that (i.e. UNNEST([1,2,3]) becomes UNNEST((SELECT [1,2,3])) + auto select_node = make_uniq(); + select_node->select_list = std::move(expressions); + select_node->from_table = make_uniq(); + subquery_node = std::move(select_node); + binder->can_contain_nulls = true; auto node = binder->BindNode(*subquery_node); subquery = make_uniq(std::move(binder), std::move(node)); MoveCorrelatedExpressions(*subquery->binder); - return true; } bool Binder::BindTableFunctionParameters(TableFunctionCatalogEntry &table_function, @@ -56,10 +95,13 @@ bool Binder::BindTableFunctionParameters(TableFunctionCatalogEntry &table_functi vector &arguments, vector ¶meters, named_parameter_map_t &named_parameters, unique_ptr &subquery, ErrorData &error) { - if (IsTableInTableOutFunction(table_function)) { - // special case binding for table-in table-out function - arguments.emplace_back(LogicalTypeId::TABLE); - return BindTableInTableOutFunction(expressions, subquery, error); + auto bind_type = GetTableFunctionBindType(table_function, expressions); + if (bind_type == TableFunctionBindType::TABLE_IN_OUT_FUNCTION) { + // bind table in-out function + BindTableInTableOutFunction(expressions, subquery); + // fetch the arguments from the subquery + arguments = subquery->subquery->types; + return true; } bool seen_subquery = false; for (auto &child : expressions) { @@ -77,7 +119,8 @@ bool Binder::BindTableFunctionParameters(TableFunctionCatalogEntry &table_functi } } } - if (child->type == ExpressionType::SUBQUERY) { + if (bind_type == TableFunctionBindType::TABLE_PARAMETER_FUNCTION && child->type == ExpressionType::SUBQUERY) { + D_ASSERT(table_function.functions.Size() == 1); auto fun = table_function.functions.GetFunctionByOffset(0); if (table_function.functions.Size() != 1 || fun.arguments.empty() || fun.arguments[0].id() != LogicalTypeId::TABLE) { @@ -85,20 +128,19 @@ bool Binder::BindTableFunctionParameters(TableFunctionCatalogEntry &table_functi "Only table-in-out functions can have subquery parameters - %s only accepts constant parameters", fun.name); } - // this separate subquery binding path is only used by python_map - // FIXME: this should be unified with `BindTableInTableOutFunction` above if (seen_subquery) { error = ErrorData("Table function can have at most one subquery parameter"); return false; } auto binder = Binder::CreateBinder(this->context, this); + binder->can_contain_nulls = true; auto &se = child->Cast(); auto node = binder->BindNode(*se.subquery->node); subquery = make_uniq(std::move(binder), std::move(node)); + MoveCorrelatedExpressions(*subquery->binder); seen_subquery = true; arguments.emplace_back(LogicalTypeId::TABLE); - parameters.emplace_back( - Value(LogicalType::INVALID)); // this is a dummy value so the lengths of arguments and parameter match + parameters.emplace_back(Value()); continue; } @@ -273,30 +315,46 @@ unique_ptr Binder::Bind(TableFunctionRef &ref) { // now check the named parameters BindNamedParameters(table_function.named_parameters, named_parameters, error_context, table_function.name); - // cast the parameters to the type of the function - for (idx_t i = 0; i < arguments.size(); i++) { - auto target_type = i < table_function.arguments.size() ? table_function.arguments[i] : table_function.varargs; - - if (target_type != LogicalType::ANY && target_type != LogicalType::TABLE && - target_type != LogicalType::POINTER && target_type.id() != LogicalTypeId::LIST) { - parameters[i] = parameters[i].CastAs(context, target_type); - } - } - vector input_table_types; vector input_table_names; if (subquery) { input_table_types = subquery->subquery->types; input_table_names = subquery->subquery->names; + } else if (table_function.in_out_function) { + for (auto ¶m : parameters) { + input_table_types.push_back(param.type()); + input_table_names.push_back(string()); + } } - auto get = BindTableFunctionInternal(table_function, ref, std::move(parameters), std::move(named_parameters), - std::move(input_table_types), std::move(input_table_names)); - if (subquery) { - get->children.push_back(Binder::CreatePlan(*subquery)); + if (!parameters.empty()) { + // cast the parameters to the type of the function + for (idx_t i = 0; i < arguments.size(); i++) { + auto target_type = + i < table_function.arguments.size() ? table_function.arguments[i] : table_function.varargs; + + if (target_type != LogicalType::ANY && target_type != LogicalType::POINTER && + target_type.id() != LogicalTypeId::LIST && target_type != LogicalType::TABLE) { + parameters[i] = parameters[i].CastAs(context, target_type); + } + } + } else if (subquery) { + for (idx_t i = 0; i < arguments.size(); i++) { + auto target_type = + i < table_function.arguments.size() ? table_function.arguments[i] : table_function.varargs; + + if (target_type != LogicalType::ANY && target_type != LogicalType::POINTER && + target_type.id() != LogicalTypeId::LIST) { + input_table_types[i] = target_type; + } + } } - return make_uniq_base(std::move(get)); + auto get = BindTableFunctionInternal(table_function, ref, std::move(parameters), std::move(named_parameters), + std::move(input_table_types), std::move(input_table_names)); + auto table_function_ref = make_uniq(std::move(get)); + table_function_ref->subquery = std::move(subquery); + return std::move(table_function_ref); } } // namespace duckdb diff --git a/src/planner/binder/tableref/plan_table_function.cpp b/src/planner/binder/tableref/plan_table_function.cpp index dffbd320adf..3be48aa6c22 100644 --- a/src/planner/binder/tableref/plan_table_function.cpp +++ b/src/planner/binder/tableref/plan_table_function.cpp @@ -4,6 +4,10 @@ namespace duckdb { unique_ptr Binder::CreatePlan(BoundTableFunction &ref) { + if (ref.subquery) { + auto child_node = CreatePlan(*ref.subquery); + ref.get->children.push_back(std::move(child_node)); + } return std::move(ref.get); } diff --git a/src/planner/expression/bound_cast_expression.cpp b/src/planner/expression/bound_cast_expression.cpp index 81aaf32108a..bc23de68f65 100644 --- a/src/planner/expression/bound_cast_expression.cpp +++ b/src/planner/expression/bound_cast_expression.cpp @@ -158,17 +158,7 @@ bool BoundCastExpression::CastIsInvertible(const LogicalType &source_type, const } break; case LogicalTypeId::VARCHAR: - switch (target_type.id()) { - case LogicalTypeId::TIMESTAMP: - case LogicalTypeId::TIMESTAMP_NS: - case LogicalTypeId::TIMESTAMP_MS: - case LogicalTypeId::TIMESTAMP_SEC: - case LogicalTypeId::TIMESTAMP_TZ: - return true; - default: - return false; - } - break; + return false; default: break; } diff --git a/src/planner/expression_binder.cpp b/src/planner/expression_binder.cpp index 649ab82a8b5..4551525b62c 100644 --- a/src/planner/expression_binder.cpp +++ b/src/planner/expression_binder.cpp @@ -286,16 +286,4 @@ bool ExpressionBinder::IsUnnestFunction(const string &function_name) { return function_name == "unnest" || function_name == "unlist"; } -bool ExpressionBinder::IsLambdaFunction(const FunctionExpression &function) { - // check for lambda parameters, ignore ->> operator (JSON extension) - if (function.function_name != "->>") { - for (auto &child : function.children) { - if (child->expression_class == ExpressionClass::LAMBDA) { - return true; - } - } - } - return false; -} - } // namespace duckdb diff --git a/src/planner/expression_iterator.cpp b/src/planner/expression_iterator.cpp index 47feaeb1367..1b271112e39 100644 --- a/src/planner/expression_iterator.cpp +++ b/src/planner/expression_iterator.cpp @@ -239,6 +239,21 @@ void BoundNodeVisitor::VisitBoundQueryNode(BoundQueryNode &node) { } } +class LogicalBoundNodeVisitor : public LogicalOperatorVisitor { +public: + explicit LogicalBoundNodeVisitor(BoundNodeVisitor &parent) : parent(parent) { + } + + void VisitExpression(unique_ptr *expression) override { + auto &expr = **expression; + parent.VisitExpression(*expression); + VisitExpressionChildren(expr); + } + +protected: + BoundNodeVisitor &parent; +}; + void BoundNodeVisitor::VisitBoundTableRef(BoundTableRef &ref) { switch (ref.type) { case TableReferenceType::EXPRESSION_LIST: { @@ -264,7 +279,17 @@ void BoundNodeVisitor::VisitBoundTableRef(BoundTableRef &ref) { VisitBoundQueryNode(*bound_subquery.subquery); break; } - case TableReferenceType::TABLE_FUNCTION: + case TableReferenceType::TABLE_FUNCTION: { + auto &bound_table_function = ref.Cast(); + LogicalBoundNodeVisitor node_visitor(*this); + if (bound_table_function.get) { + node_visitor.VisitOperator(*bound_table_function.get); + } + if (bound_table_function.subquery) { + VisitBoundTableRef(*bound_table_function.subquery); + } + break; + } case TableReferenceType::EMPTY_FROM: case TableReferenceType::BASE_TABLE: case TableReferenceType::CTE: diff --git a/src/planner/operator/logical_copy_to_file.cpp b/src/planner/operator/logical_copy_to_file.cpp index e272a52cf50..6b6e2116084 100644 --- a/src/planner/operator/logical_copy_to_file.cpp +++ b/src/planner/operator/logical_copy_to_file.cpp @@ -34,6 +34,7 @@ void LogicalCopyToFile::Serialize(Serializer &serializer) const { serializer.WriteProperty(213, "file_extension", file_extension); serializer.WriteProperty(214, "rotate", rotate); + serializer.WriteProperty(215, "return_type", return_type); } unique_ptr LogicalCopyToFile::Deserialize(Deserializer &deserializer) { @@ -83,6 +84,7 @@ unique_ptr LogicalCopyToFile::Deserialize(Deserializer &deseria deserializer.ReadPropertyWithDefault(213, "file_extension", std::move(default_extension)); auto rotate = deserializer.ReadPropertyWithDefault(214, "rotate", false); + auto return_type = deserializer.ReadPropertyWithDefault(215, "return_type", CopyFunctionReturnType::CHANGED_ROWS); auto result = make_uniq(function, std::move(bind_data), std::move(copy_info)); result->file_path = file_path; @@ -96,10 +98,22 @@ unique_ptr LogicalCopyToFile::Deserialize(Deserializer &deseria result->names = names; result->expected_types = expected_types; result->rotate = rotate; + result->return_type = return_type; return std::move(result); } +vector LogicalCopyToFile::GetColumnBindings() { + switch (return_type) { + case CopyFunctionReturnType::CHANGED_ROWS: + return {ColumnBinding(0, 0)}; + case CopyFunctionReturnType::CHANGED_ROWS_AND_FILE_LIST: + return {ColumnBinding(0, 0), ColumnBinding(0, 1)}; + default: + throw NotImplementedException("Unknown CopyFunctionReturnType"); + } +} + idx_t LogicalCopyToFile::EstimateCardinality(ClientContext &context) { return 1; } diff --git a/src/planner/operator/logical_get.cpp b/src/planner/operator/logical_get.cpp index 188b0520660..80f678672e8 100644 --- a/src/planner/operator/logical_get.cpp +++ b/src/planner/operator/logical_get.cpp @@ -122,6 +122,9 @@ idx_t LogicalGet::EstimateCardinality(ClientContext &context) { return node_stats->estimated_cardinality; } } + if (!children.empty()) { + return children[0]->EstimateCardinality(context); + } return 1; } diff --git a/src/planner/subquery/flatten_dependent_join.cpp b/src/planner/subquery/flatten_dependent_join.cpp index 55cb43960d0..4a8a128fc39 100644 --- a/src/planner/subquery/flatten_dependent_join.cpp +++ b/src/planner/subquery/flatten_dependent_join.cpp @@ -667,6 +667,9 @@ unique_ptr FlattenDependentJoins::PushDownDependentJoinInternal } this->delim_offset = get.returned_types.size(); this->data_offset = 0; + + RewriteCorrelatedExpressions rewriter(base_binding, correlated_map, lateral_depth); + rewriter.VisitOperator(*plan); return plan; } case LogicalOperatorType::LOGICAL_MATERIALIZED_CTE: diff --git a/src/storage/buffer/block_handle.cpp b/src/storage/buffer/block_handle.cpp index b9ccc1996bc..b307d2d141d 100644 --- a/src/storage/buffer/block_handle.cpp +++ b/src/storage/buffer/block_handle.cpp @@ -70,6 +70,17 @@ unique_ptr AllocateBlock(BlockManager &block_manager, unique_ptr &handle, data_ptr_t data, + unique_ptr reusable_buffer) { + D_ASSERT(handle->state != BlockState::BLOCK_LOADED); + // copy over the data into the block from the file buffer + auto block = AllocateBlock(handle->block_manager, std::move(reusable_buffer), handle->block_id); + memcpy(block->InternalBuffer(), data, block->AllocSize()); + handle->buffer = std::move(block); + handle->state = BlockState::BLOCK_LOADED; + return BufferHandle(handle, handle->buffer.get()); +} + BufferHandle BlockHandle::Load(shared_ptr &handle, unique_ptr reusable_buffer) { if (handle->state == BlockState::BLOCK_LOADED) { // already loaded diff --git a/src/storage/buffer/buffer_handle.cpp b/src/storage/buffer/buffer_handle.cpp index dc3be3f2844..21226eb685d 100644 --- a/src/storage/buffer/buffer_handle.cpp +++ b/src/storage/buffer/buffer_handle.cpp @@ -11,7 +11,7 @@ BufferHandle::BufferHandle(shared_ptr handle_p, FileBuffer *node_p) : handle(std::move(handle_p)), node(node_p) { } -BufferHandle::BufferHandle(BufferHandle &&other) noexcept { +BufferHandle::BufferHandle(BufferHandle &&other) noexcept : node(nullptr) { std::swap(node, other.node); std::swap(handle, other.handle); } diff --git a/src/storage/checkpoint_manager.cpp b/src/storage/checkpoint_manager.cpp index 8f5d834cfe8..dea1e5ae94d 100644 --- a/src/storage/checkpoint_manager.cpp +++ b/src/storage/checkpoint_manager.cpp @@ -243,6 +243,12 @@ void SingleFileCheckpointReader::LoadFromStorage() { return; } + if (block_manager.IsRemote()) { + auto metadata_blocks = metadata_manager.GetBlocks(); + auto &buffer_manager = BufferManager::GetBufferManager(storage.GetDatabase()); + buffer_manager.Prefetch(metadata_blocks); + } + // create the MetadataReader to read from the storage MetadataReader reader(metadata_manager, meta_block); auto transaction = CatalogTransaction::GetSystemTransaction(catalog.GetDatabase()); diff --git a/src/storage/compression/fixed_size_uncompressed.cpp b/src/storage/compression/fixed_size_uncompressed.cpp index bbccd3f0e16..9762cfb191d 100644 --- a/src/storage/compression/fixed_size_uncompressed.cpp +++ b/src/storage/compression/fixed_size_uncompressed.cpp @@ -260,7 +260,7 @@ CompressionFunction FixedSizeGetFunction(PhysicalType data_type) { UncompressedFunctions::Compress, UncompressedFunctions::FinalizeCompress, FixedSizeInitScan, FixedSizeScan, FixedSizeScanPartial, FixedSizeFetchRow, UncompressedFunctions::EmptySkip, nullptr, FixedSizeInitAppend, - FixedSizeAppend, FixedSizeFinalizeAppend, nullptr); + FixedSizeAppend, FixedSizeFinalizeAppend); } CompressionFunction FixedSizeUncompressed::GetFunction(PhysicalType data_type) { diff --git a/src/storage/compression/string_uncompressed.cpp b/src/storage/compression/string_uncompressed.cpp index dea2ef6fc9f..9cec7d74658 100644 --- a/src/storage/compression/string_uncompressed.cpp +++ b/src/storage/compression/string_uncompressed.cpp @@ -62,6 +62,19 @@ idx_t UncompressedStringStorage::StringFinalAnalyze(AnalyzeState &state_p) { //===--------------------------------------------------------------------===// // Scan //===--------------------------------------------------------------------===// +void UncompressedStringInitPrefetch(ColumnSegment &segment, PrefetchState &prefetch_state) { + prefetch_state.AddBlock(segment.block); + auto segment_state = segment.GetSegmentState(); + if (segment_state) { + auto &state = segment_state->Cast(); + auto &block_manager = segment.GetBlockManager(); + for (auto &block_id : state.on_disk_blocks) { + auto block_handle = state.GetHandle(block_manager, block_id); + prefetch_state.AddBlock(block_handle); + } + } +} + unique_ptr UncompressedStringStorage::StringInitScan(ColumnSegment &segment) { auto result = make_uniq(); auto &buffer_manager = BufferManager::GetBufferManager(segment.db); @@ -240,7 +253,7 @@ CompressionFunction StringUncompressed::GetFunction(PhysicalType data_type) { UncompressedStringStorage::StringInitAppend, UncompressedStringStorage::StringAppend, UncompressedStringStorage::FinalizeAppend, nullptr, UncompressedStringStorage::SerializeState, UncompressedStringStorage::DeserializeState, - UncompressedStringStorage::CleanupState); + UncompressedStringStorage::CleanupState, UncompressedStringInitPrefetch); } //===--------------------------------------------------------------------===// diff --git a/src/storage/metadata/metadata_manager.cpp b/src/storage/metadata/metadata_manager.cpp index 2fba4fc1bbc..bb3ad18a6c5 100644 --- a/src/storage/metadata/metadata_manager.cpp +++ b/src/storage/metadata/metadata_manager.cpp @@ -26,7 +26,7 @@ MetadataHandle MetadataManager::AllocateHandle() { break; } } - if (free_block == INVALID_BLOCK) { + if (free_block == INVALID_BLOCK || free_block > PeekNextBlockId()) { free_block = AllocateNewBlock(); } D_ASSERT(free_block != INVALID_BLOCK); @@ -315,6 +315,18 @@ vector MetadataManager::GetMetadataInfo() const { return result; } +vector> MetadataManager::GetBlocks() const { + vector> result; + for (auto &entry : blocks) { + result.push_back(entry.second.block); + } + return result; +} + +block_id_t MetadataManager::PeekNextBlockId() { + return block_manager.PeekFreeBlockId(); +} + block_id_t MetadataManager::GetNextBlockId() { return block_manager.GetFreeBlockId(); } diff --git a/src/storage/serialization/serialize_parse_info.cpp b/src/storage/serialization/serialize_parse_info.cpp index 329f623a9b2..6a8925345bf 100644 --- a/src/storage/serialization/serialize_parse_info.cpp +++ b/src/storage/serialization/serialize_parse_info.cpp @@ -465,11 +465,13 @@ unique_ptr SetNotNullInfo::Deserialize(Deserializer &deserialize void TransactionInfo::Serialize(Serializer &serializer) const { ParseInfo::Serialize(serializer); serializer.WriteProperty(200, "type", type); + serializer.WriteProperty(201, "modifier", modifier); } unique_ptr TransactionInfo::Deserialize(Deserializer &deserializer) { auto result = duckdb::unique_ptr(new TransactionInfo()); deserializer.ReadProperty(200, "type", result->type); + deserializer.ReadProperty(201, "modifier", result->modifier); return std::move(result); } diff --git a/src/storage/single_file_block_manager.cpp b/src/storage/single_file_block_manager.cpp index 1b182f2b887..0099cb8ef41 100644 --- a/src/storage/single_file_block_manager.cpp +++ b/src/storage/single_file_block_manager.cpp @@ -348,6 +348,15 @@ block_id_t SingleFileBlockManager::GetFreeBlockId() { return block; } +block_id_t SingleFileBlockManager::PeekFreeBlockId() { + lock_guard lock(block_lock); + if (!free_list.empty()) { + return *free_list.begin(); + } else { + return max_block; + } +} + void SingleFileBlockManager::MarkBlockAsFree(block_id_t block_id) { lock_guard lock(block_lock); D_ASSERT(block_id >= 0); @@ -411,6 +420,10 @@ idx_t SingleFileBlockManager::FreeBlocks() { return free_list.size(); } +bool SingleFileBlockManager::IsRemote() { + return !handle->OnDiskFile(); +} + unique_ptr SingleFileBlockManager::ConvertBlock(block_id_t block_id, FileBuffer &source_buffer) { D_ASSERT(source_buffer.AllocSize() == Storage::BLOCK_ALLOC_SIZE); return make_uniq(source_buffer, block_id); @@ -427,10 +440,39 @@ unique_ptr SingleFileBlockManager::CreateBlock(block_id_t block_id, FileB return result; } +idx_t SingleFileBlockManager::GetBlockLocation(block_id_t block_id) { + return BLOCK_START + NumericCast(block_id) * Storage::BLOCK_ALLOC_SIZE; +} + void SingleFileBlockManager::Read(Block &block) { D_ASSERT(block.id >= 0); D_ASSERT(std::find(free_list.begin(), free_list.end(), block.id) == free_list.end()); - ReadAndChecksum(block, BLOCK_START + NumericCast(block.id) * Storage::BLOCK_ALLOC_SIZE); + ReadAndChecksum(block, GetBlockLocation(block.id)); +} + +void SingleFileBlockManager::ReadBlocks(FileBuffer &buffer, block_id_t start_block, idx_t block_count) { + D_ASSERT(start_block >= 0); + D_ASSERT(block_count >= 1); + + // read the buffer from disk + auto location = GetBlockLocation(start_block); + buffer.Read(*handle, location); + + // for each of the blocks - verify the checksum + auto ptr = buffer.InternalBuffer(); + for (idx_t i = 0; i < block_count; i++) { + // compute the checksum + auto start_ptr = ptr + i * Storage::BLOCK_ALLOC_SIZE; + auto stored_checksum = Load(start_ptr); + uint64_t computed_checksum = Checksum(start_ptr + Storage::BLOCK_HEADER_SIZE, Storage::BLOCK_SIZE); + // verify the checksum + if (stored_checksum != computed_checksum) { + throw IOException( + "Corrupt database file: computed checksum %llu does not match stored checksum %llu in block " + "at location %llu", + computed_checksum, stored_checksum, location + i * Storage::BLOCK_ALLOC_SIZE); + } + } } void SingleFileBlockManager::Write(FileBuffer &buffer, block_id_t block_id) { diff --git a/src/storage/standard_buffer_manager.cpp b/src/storage/standard_buffer_manager.cpp index ff8b0c8afd9..d29bdba4e6b 100644 --- a/src/storage/standard_buffer_manager.cpp +++ b/src/storage/standard_buffer_manager.cpp @@ -8,8 +8,8 @@ #include "duckdb/storage/buffer/buffer_pool.hpp" #include "duckdb/storage/in_memory_block_manager.hpp" #include "duckdb/storage/storage_manager.hpp" -#include "duckdb/storage/temporary_memory_manager.hpp" #include "duckdb/storage/temporary_file_manager.hpp" +#include "duckdb/storage/temporary_memory_manager.hpp" namespace duckdb { @@ -201,46 +201,154 @@ void StandardBufferManager::ReAllocate(shared_ptr &handle, idx_t bl handle->ResizeBuffer(block_size, memory_delta); } +void StandardBufferManager::BatchRead(vector> &handles, const map &load_map, + block_id_t first_block, block_id_t last_block) { + auto &block_manager = handles[0]->block_manager; + idx_t block_count = NumericCast(last_block - first_block + 1); +#ifndef DUCKDB_ALTERNATIVE_VERIFY + if (block_count == 1) { + // prefetching with block_count == 1 has no performance impact since we can't batch reads + // skip the prefetch in this case + // we do it anyway if alternative_verify is on for extra testing + return; + } +#endif + + // allocate a buffer to hold the data of all of the blocks + auto intermediate_buffer = Allocate(MemoryTag::BASE_TABLE, block_count * Storage::BLOCK_SIZE); + // perform a batch read of the blocks into the buffer + block_manager.ReadBlocks(intermediate_buffer.GetFileBuffer(), first_block, block_count); + + // the blocks are read - now we need to assign them to the individual blocks + for (idx_t block_idx = 0; block_idx < block_count; block_idx++) { + block_id_t block_id = first_block + NumericCast(block_idx); + auto entry = load_map.find(block_id); + D_ASSERT(entry != load_map.end()); // if we allow gaps we might not return true here + auto &handle = handles[entry->second]; + + // reserve memory for the block + idx_t required_memory = handle->memory_usage; + unique_ptr reusable_buffer; + auto reservation = + EvictBlocksOrThrow(handle->tag, required_memory, &reusable_buffer, "failed to pin block of size %s%s", + StringUtil::BytesToHumanReadableString(required_memory)); + // now load the block from the buffer + // note that we discard the buffer handle - we do not keep it around + // the prefetching relies on the block handle being pinned again during the actual read before it is evicted + BufferHandle buf; + { + lock_guard lock(handle->lock); + if (handle->state == BlockState::BLOCK_LOADED) { + // the block is loaded already by another thread - free up the reservation and continue + reservation.Resize(0); + continue; + } + auto block_ptr = + intermediate_buffer.GetFileBuffer().InternalBuffer() + block_idx * Storage::BLOCK_ALLOC_SIZE; + buf = BlockHandle::LoadFromBuffer(handle, block_ptr, std::move(reusable_buffer)); + handle->readers = 1; + handle->memory_charge = std::move(reservation); + } + } +} + +void StandardBufferManager::Prefetch(vector> &handles) { + // figure out which set of blocks we should load + map to_be_loaded; + for (idx_t block_idx = 0; block_idx < handles.size(); block_idx++) { + auto &handle = handles[block_idx]; + lock_guard lock(handle->lock); + if (handle->state != BlockState::BLOCK_LOADED) { + // need to load this block - add it to the map + to_be_loaded.insert(make_pair(handle->BlockId(), block_idx)); + } + } + if (to_be_loaded.empty()) { + // nothing to fetch + return; + } + // iterate over the blocks and perform bulk reads + block_id_t first_block = -1; + block_id_t previous_block_id = -1; + for (auto &entry : to_be_loaded) { + if (previous_block_id < 0) { + // this the first block we are seeing + first_block = entry.first; + previous_block_id = first_block; + } else if (previous_block_id + 1 == entry.first) { + // this block is adjacent to the previous block - add it to the batch read + previous_block_id = entry.first; + } else { + // this block is not adjacent to the previous block + // perform the batch read for the previous batch + BatchRead(handles, to_be_loaded, first_block, previous_block_id); + + // set the first_block and previous_block_id to the current block + first_block = entry.first; + previous_block_id = entry.first; + } + } + // batch read the final batch + BatchRead(handles, to_be_loaded, first_block, previous_block_id); +} + BufferHandle StandardBufferManager::Pin(shared_ptr &handle) { + // we need to be careful not to return the BufferHandle to this block while holding the BlockHandle's lock + // as exiting this function's scope may cause the destructor of the BufferHandle to be called while holding the lock + // the destructor calls Unpin, which grabs the BlockHandle's lock again, causing a deadlock + BufferHandle buf; + idx_t required_memory; { // lock the block lock_guard lock(handle->lock); // check if the block is already loaded if (handle->state == BlockState::BLOCK_LOADED) { - // the block is loaded, increment the reader count and return a pointer to the handle + // the block is loaded, increment the reader count and set the BufferHandle handle->readers++; - return handle->Load(handle); + buf = handle->Load(handle); } required_memory = handle->memory_usage; } - // evict blocks until we have space for the current block - unique_ptr reusable_buffer; - 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 meantime) - lock_guard lock(handle->lock); - // check if the block is already loaded - if (handle->state == BlockState::BLOCK_LOADED) { - // the block is loaded, increment the reader count and return a pointer to the handle - handle->readers++; - reservation.Resize(0); - return handle->Load(handle); - } - // now we can actually load the current block - D_ASSERT(handle->readers == 0); - handle->readers = 1; - auto buf = handle->Load(handle, std::move(reusable_buffer)); - handle->memory_charge = std::move(reservation); - // In the case of a variable sized block, the buffer may be smaller than a full block. - int64_t delta = NumericCast(handle->buffer->AllocSize()) - NumericCast(handle->memory_usage); - if (delta) { - D_ASSERT(delta < 0); - handle->memory_usage += NumericCast(delta); - handle->memory_charge.Resize(handle->memory_usage); + + if (buf.IsValid()) { + return buf; // the block was already loaded, return it without holding the BlockHandle's lock + } else { + // evict blocks until we have space for the current block + unique_ptr reusable_buffer; + 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 meantime) + lock_guard lock(handle->lock); + // check if the block is already loaded + if (handle->state == BlockState::BLOCK_LOADED) { + // the block is loaded, increment the reader count and return a pointer to the handle + handle->readers++; + reservation.Resize(0); + buf = handle->Load(handle); + } else { + // now we can actually load the current block + D_ASSERT(handle->readers == 0); + handle->readers = 1; + buf = handle->Load(handle, std::move(reusable_buffer)); + handle->memory_charge = std::move(reservation); + // in the case of a variable sized block, the buffer may be smaller than a full block. + int64_t delta = + NumericCast(handle->buffer->AllocSize()) - NumericCast(handle->memory_usage); + if (delta) { + D_ASSERT(delta < 0); + handle->memory_usage += static_cast(delta); + handle->memory_charge.Resize(handle->memory_usage); + } + D_ASSERT(handle->memory_usage == handle->buffer->AllocSize()); + } } - D_ASSERT(handle->memory_usage == handle->buffer->AllocSize()); + + // we should have a valid BufferHandle by now, either because the block was already loaded, or because we loaded it + // return it without holding the BlockHandle's lock + D_ASSERT(buf.IsValid()); return buf; } @@ -428,9 +536,15 @@ vector StandardBufferManager::GetTemporaryFiles() { if (!StringUtil::EndsWith(name, ".block")) { return; } + + // Another process or thread can delete the file before we can get its file size. + auto handle = fs.OpenFile(name, FileFlags::FILE_FLAGS_READ | FileFlags::FILE_FLAGS_NULL_IF_NOT_EXISTS); + if (!handle) { + return; + } + TemporaryFileInformation info; info.path = name; - auto handle = fs.OpenFile(name, FileFlags::FILE_FLAGS_READ); info.size = NumericCast(fs.GetFileSize(*handle)); handle.reset(); result.push_back(info); diff --git a/src/storage/table/array_column_data.cpp b/src/storage/table/array_column_data.cpp index 44ae4db3ccb..af9a54f028e 100644 --- a/src/storage/table/array_column_data.cpp +++ b/src/storage/table/array_column_data.cpp @@ -30,6 +30,13 @@ bool ArrayColumnData::CheckZonemap(ColumnScanState &state, TableFilter &filter) return false; } +void ArrayColumnData::InitializePrefetch(PrefetchState &prefetch_state, ColumnScanState &scan_state, idx_t rows) { + ColumnData::InitializePrefetch(prefetch_state, scan_state, rows); + validity.InitializePrefetch(prefetch_state, scan_state.child_states[0], rows); + auto array_size = ArrayType::GetSize(type); + child_column->InitializePrefetch(prefetch_state, scan_state.child_states[1], rows * array_size); +} + void ArrayColumnData::InitializeScan(ColumnScanState &state) { // initialize the validity segment D_ASSERT(state.child_states.size() == 2); diff --git a/src/storage/table/column_data.cpp b/src/storage/table/column_data.cpp index cbb36c51119..fc4f8905562 100644 --- a/src/storage/table/column_data.cpp +++ b/src/storage/table/column_data.cpp @@ -107,6 +107,31 @@ ScanVectorType ColumnData::GetVectorScanType(ColumnScanState &state, idx_t scan_ return ScanVectorType::SCAN_ENTIRE_VECTOR; } +void ColumnData::InitializePrefetch(PrefetchState &prefetch_state, ColumnScanState &scan_state, idx_t remaining) { + auto current_segment = scan_state.current; + if (!current_segment) { + return; + } + if (!scan_state.initialized) { + // need to prefetch for the current segment if we have not yet initialized the scan for this segment + scan_state.current->InitializePrefetch(prefetch_state, scan_state); + } + idx_t row_index = scan_state.row_index; + while (remaining > 0) { + idx_t scan_count = MinValue(remaining, current_segment->start + current_segment->count - row_index); + remaining -= scan_count; + row_index += scan_count; + if (remaining > 0) { + auto next = data.GetNextSegment(current_segment); + if (!next) { + break; + } + next->InitializePrefetch(prefetch_state, scan_state); + current_segment = next; + } + } +} + idx_t ColumnData::ScanVector(ColumnScanState &state, Vector &result, idx_t remaining, ScanVectorType scan_type) { if (scan_type == ScanVectorType::SCAN_FLAT_VECTOR && result.GetVectorType() != VectorType::FLAT_VECTOR) { throw InternalException("ScanVector called with SCAN_FLAT_VECTOR but result is not a flat vector"); diff --git a/src/storage/table/column_segment.cpp b/src/storage/table/column_segment.cpp index 47cccb5547d..221f6408952 100644 --- a/src/storage/table/column_segment.cpp +++ b/src/storage/table/column_segment.cpp @@ -96,6 +96,18 @@ ColumnSegment::~ColumnSegment() { //===--------------------------------------------------------------------===// // Scan //===--------------------------------------------------------------------===// +void ColumnSegment::InitializePrefetch(PrefetchState &prefetch_state, ColumnScanState &) { + if (!block || block->BlockId() >= MAXIMUM_BLOCK) { + // not an on-disk block + return; + } + if (function.get().init_prefetch) { + function.get().init_prefetch(*this, prefetch_state); + } else { + prefetch_state.AddBlock(block); + } +} + void ColumnSegment::InitializeScan(ColumnScanState &state) { state.scan_state = function.get().init_scan(*this); } diff --git a/src/storage/table/list_column_data.cpp b/src/storage/table/list_column_data.cpp index ce472ef40a3..6e730607e6b 100644 --- a/src/storage/table/list_column_data.cpp +++ b/src/storage/table/list_column_data.cpp @@ -29,6 +29,20 @@ bool ListColumnData::CheckZonemap(ColumnScanState &state, TableFilter &filter) { return false; } +void ListColumnData::InitializePrefetch(PrefetchState &prefetch_state, ColumnScanState &scan_state, idx_t rows) { + ColumnData::InitializePrefetch(prefetch_state, scan_state, rows); + validity.InitializePrefetch(prefetch_state, scan_state.child_states[0], rows); + + // we can't know how many rows we need to prefetch for the child of this list without looking at the actual data + // we make an estimation by looking at how many rows the child column has versus this column + // e.g if the child column has 10K rows, and we have 1K rows, we estimate that each list has 10 elements + idx_t rows_per_list = 1; + if (child_column->count > this->count && this->count > 0) { + rows_per_list = child_column->count / this->count; + } + child_column->InitializePrefetch(prefetch_state, scan_state.child_states[1], rows * rows_per_list); +} + void ListColumnData::InitializeScan(ColumnScanState &state) { ColumnData::InitializeScan(state); diff --git a/src/storage/table/row_group.cpp b/src/storage/table/row_group.cpp index 4c1f1ead8ad..55df57f57af 100644 --- a/src/storage/table/row_group.cpp +++ b/src/storage/table/row_group.cpp @@ -463,6 +463,7 @@ void RowGroup::TemplatedScan(TransactionData transaction, CollectionScanState &s if (!CheckZonemapSegments(state)) { continue; } + // second, scan the version chunk manager to figure out which tuples to load for this transaction idx_t count; SelectionVector valid_sel(STANDARD_VECTOR_SIZE); @@ -484,6 +485,26 @@ void RowGroup::TemplatedScan(TransactionData transaction, CollectionScanState &s } else { count = max_count; } + auto &block_manager = GetBlockManager(); +#ifndef DUCKDB_ALTERNATIVE_VERIFY + // // in regular operation we only prefetch from remote file systems + // // when alternative verify is set, we always prefetch for testing purposes + if (block_manager.IsRemote()) +#else + if (!block_manager.InMemory()) +#endif + { + PrefetchState prefetch_state; + for (idx_t i = 0; i < column_ids.size(); i++) { + const auto &column = column_ids[i]; + if (column != COLUMN_IDENTIFIER_ROW_ID) { + GetColumn(column).InitializePrefetch(prefetch_state, state.column_scans[i], max_count); + } + } + auto &buffer_manager = block_manager.buffer_manager; + buffer_manager.Prefetch(prefetch_state.blocks); + } + if (count == max_count && !table_filters) { // scan all vectors completely: full scan without deletions or table filters for (idx_t i = 0; i < column_ids.size(); i++) { diff --git a/src/storage/table/scan_state.cpp b/src/storage/table/scan_state.cpp index 6931d1056fd..52e0277c5ac 100644 --- a/src/storage/table/scan_state.cpp +++ b/src/storage/table/scan_state.cpp @@ -138,4 +138,11 @@ bool CollectionScanState::ScanCommitted(DataChunk &result, TableScanType type) { return false; } +PrefetchState::~PrefetchState() { +} + +void PrefetchState::AddBlock(shared_ptr block) { + blocks.push_back(std::move(block)); +} + } // namespace duckdb diff --git a/src/storage/table/standard_column_data.cpp b/src/storage/table/standard_column_data.cpp index 7f6976c7eec..a70ee42a9e5 100644 --- a/src/storage/table/standard_column_data.cpp +++ b/src/storage/table/standard_column_data.cpp @@ -60,6 +60,11 @@ bool StandardColumnData::CheckZonemap(ColumnScanState &state, TableFilter &filte } } +void StandardColumnData::InitializePrefetch(PrefetchState &prefetch_state, ColumnScanState &scan_state, idx_t rows) { + ColumnData::InitializePrefetch(prefetch_state, scan_state, rows); + validity.InitializePrefetch(prefetch_state, scan_state.child_states[0], rows); +} + void StandardColumnData::InitializeScan(ColumnScanState &state) { ColumnData::InitializeScan(state); diff --git a/src/storage/table/struct_column_data.cpp b/src/storage/table/struct_column_data.cpp index 14d28e1b84c..59124048f6a 100644 --- a/src/storage/table/struct_column_data.cpp +++ b/src/storage/table/struct_column_data.cpp @@ -68,6 +68,13 @@ idx_t StructColumnData::GetMaxEntry() { return sub_columns[0]->GetMaxEntry(); } +void StructColumnData::InitializePrefetch(PrefetchState &prefetch_state, ColumnScanState &scan_state, idx_t rows) { + validity.InitializePrefetch(prefetch_state, scan_state.child_states[0], rows); + for (idx_t i = 0; i < sub_columns.size(); i++) { + sub_columns[i]->InitializePrefetch(prefetch_state, scan_state.child_states[i + 1], rows); + } +} + void StructColumnData::InitializeScan(ColumnScanState &state) { D_ASSERT(state.child_states.size() == sub_columns.size() + 1); state.row_index = 0; diff --git a/src/transaction/duck_transaction_manager.cpp b/src/transaction/duck_transaction_manager.cpp index 12feb9bb501..5c188b83ee4 100644 --- a/src/transaction/duck_transaction_manager.cpp +++ b/src/transaction/duck_transaction_manager.cpp @@ -42,7 +42,11 @@ DuckTransactionManager &DuckTransactionManager::Get(AttachedDatabase &db) { Transaction &DuckTransactionManager::StartTransaction(ClientContext &context) { // obtain the transaction lock during this function - lock_guard start_lock(start_transaction_lock); + auto &meta_transaction = MetaTransaction::Get(context); + unique_ptr> start_lock; + if (!meta_transaction.IsReadOnly()) { + start_lock = make_uniq>(start_transaction_lock); + } lock_guard lock(transaction_lock); if (current_start_timestamp >= TRANSACTION_ID_START) { // LCOV_EXCL_START throw InternalException("Cannot start more transactions, ran out of " diff --git a/src/transaction/meta_transaction.cpp b/src/transaction/meta_transaction.cpp index fa2ce280831..697dbcc6874 100644 --- a/src/transaction/meta_transaction.cpp +++ b/src/transaction/meta_transaction.cpp @@ -7,8 +7,8 @@ namespace duckdb { MetaTransaction::MetaTransaction(ClientContext &context_p, timestamp_t start_timestamp_p, idx_t catalog_version_p) - : context(context_p), start_timestamp(start_timestamp_p), catalog_version(catalog_version_p), read_only(true), - active_query(MAXIMUM_QUERY_ID), modified_database(nullptr) { + : context(context_p), start_timestamp(start_timestamp_p), catalog_version(catalog_version_p), + active_query(MAXIMUM_QUERY_ID), modified_database(nullptr), is_read_only(false) { } MetaTransaction &MetaTransaction::Get(ClientContext &context) { @@ -84,6 +84,17 @@ void MetaTransaction::RemoveTransaction(AttachedDatabase &db) { } } +void MetaTransaction::SetReadOnly() { + if (modified_database) { + throw InternalException("Cannot set MetaTransaction to read only - modifications have already been made"); + } + this->is_read_only = true; +} + +bool MetaTransaction::IsReadOnly() const { + return is_read_only; +} + Transaction &Transaction::Get(ClientContext &context, Catalog &catalog) { return Transaction::Get(context, catalog.GetAttached()); } @@ -147,6 +158,10 @@ void MetaTransaction::ModifyDatabase(AttachedDatabase &db) { // we can always modify the system and temp databases return; } + if (IsReadOnly()) { + throw TransactionException("Cannot write to database \"%s\" - transaction is launched in read-only mode", + db.GetName()); + } if (!modified_database) { modified_database = &db; diff --git a/src/transaction/transaction_context.cpp b/src/transaction/transaction_context.cpp index 7185a263894..fa9327a8c3c 100644 --- a/src/transaction/transaction_context.cpp +++ b/src/transaction/transaction_context.cpp @@ -64,6 +64,10 @@ void TransactionContext::SetAutoCommit(bool value) { } } +void TransactionContext::SetReadOnly() { + current_transaction->SetReadOnly(); +} + void TransactionContext::Rollback() { if (!current_transaction) { throw TransactionException("failed to rollback: no transaction active"); diff --git a/test/api/capi/test_capi_appender.cpp b/test/api/capi/test_capi_appender.cpp index 2582310c140..f48b68baad8 100644 --- a/test/api/capi/test_capi_appender.cpp +++ b/test/api/capi/test_capi_appender.cpp @@ -4,6 +4,32 @@ using namespace duckdb; using namespace std; +namespace { + +struct CAPIAppender { +public: + CAPIAppender(CAPITester &tester, const char *schema, const char *table) { + auto status = duckdb_appender_create(tester.connection, schema, table, &appender); + REQUIRE(status == DuckDBSuccess); + } + ~CAPIAppender() { + auto status = duckdb_appender_close(appender); + REQUIRE(status == DuckDBSuccess); + duckdb_appender_destroy(&appender); + } + operator duckdb_appender() const { + return appender; + } + operator duckdb_appender *() { + return &appender; + } + +public: + duckdb_appender appender = nullptr; +}; + +} // namespace + void TestAppenderError(duckdb_appender &appender, const string &expected) { auto error = duckdb_appender_error(appender); REQUIRE(error != nullptr); @@ -567,6 +593,59 @@ TEST_CASE("Test appender statements in C API", "[capi]") { REQUIRE(uhugeint.upper == 0); } +TEST_CASE("Test append DEFAULT in C API", "[capi]") { + CAPITester tester; + duckdb::unique_ptr result; + + REQUIRE(tester.OpenDatabase(nullptr)); + + SECTION("BASIC DEFAULT VALUE") { + tester.Query("CREATE OR REPLACE TABLE test (a INTEGER, b INTEGER DEFAULT 5)"); + { + CAPIAppender appender(tester, nullptr, "test"); + auto status = duckdb_appender_begin_row(appender); + REQUIRE(status == DuckDBSuccess); + duckdb_append_int32(appender, 42); + // Even though the column has a DEFAULT, we still require explicitly appending a value/default + status = duckdb_appender_end_row(appender); + REQUIRE(status == DuckDBError); + status = duckdb_appender_flush(appender); + REQUIRE(status == DuckDBError); + + status = duckdb_append_default(appender); + REQUIRE(status == DuckDBSuccess); + status = duckdb_appender_end_row(appender); + REQUIRE(status == DuckDBSuccess); + } + result = tester.Query("SELECT * FROM test"); + REQUIRE_NO_FAIL(*result); + REQUIRE(result->Fetch(0, 0) == 42); + REQUIRE(result->Fetch(1, 0) == 5); + } + + SECTION("NON DEFAULT VALUE") { + tester.Query("CREATE OR REPLACE TABLE test (a INTEGER, b INTEGER DEFAULT 5)"); + { + CAPIAppender appender(tester, nullptr, "test"); + auto status = duckdb_appender_begin_row(appender); + REQUIRE(status == DuckDBSuccess); + + // Append default to column without a default + status = duckdb_append_default(appender); + REQUIRE(status == DuckDBSuccess); + + status = duckdb_append_int32(appender, 42); + REQUIRE(status == DuckDBSuccess); + status = duckdb_appender_end_row(appender); + REQUIRE(status == DuckDBSuccess); + } + result = tester.Query("SELECT * FROM test"); + REQUIRE_NO_FAIL(*result); + REQUIRE(result->IsNull(0, 0)); + REQUIRE(result->Fetch(1, 0) == 42); + } +} + TEST_CASE("Test append timestamp in C API", "[capi]") { CAPITester tester; duckdb::unique_ptr result; diff --git a/test/api/capi/test_capi_prepared.cpp b/test/api/capi/test_capi_prepared.cpp index d7e2adbdd44..7ee8a6c1509 100644 --- a/test/api/capi/test_capi_prepared.cpp +++ b/test/api/capi/test_capi_prepared.cpp @@ -210,7 +210,7 @@ TEST_CASE("Test prepared statements in C API", "[capi]") { status = duckdb_execute_prepared(stmt, &res); REQUIRE(status == DuckDBSuccess); value = duckdb_value_varchar(&res, 0, 0); - REQUIRE(string(value) == "1992-09-03 12:22:33.1234+00"); + REQUIRE(StringUtil::Contains(string(value), "1992-09")); duckdb_free(value); duckdb_destroy_result(&res); diff --git a/test/api/serialized_plans/queries.sql b/test/api/serialized_plans/queries.sql index a8f73eb1223..14ceee7b690 100644 --- a/test/api/serialized_plans/queries.sql +++ b/test/api/serialized_plans/queries.sql @@ -19,3 +19,6 @@ SELECT c_name, c_custkey, o_orderkey, o_orderdate, o_totalprice, sum(l_quantity) SELECT sum(l_extendedprice * (1 - l_discount)) AS revenue FROM lineitem, part WHERE (p_partkey = l_partkey AND p_brand = 'Brand#12' AND p_container IN ('SM CASE', 'SM BOX', 'SM PACK', 'SM PKG') AND l_quantity >= 1 AND l_quantity <= 1 + 10 AND p_size BETWEEN 1 AND 5 AND l_shipmode IN ('AIR', 'AIR REG') AND l_shipinstruct = 'DELIVER IN PERSON') OR (p_partkey = l_partkey AND p_brand = 'Brand#23' AND p_container IN ('MED BAG', 'MED BOX', 'MED PKG', 'MED PACK') AND l_quantity >= 10 AND l_quantity <= 10 + 10 AND p_size BETWEEN 1 AND 10 AND l_shipmode IN ('AIR', 'AIR REG') AND l_shipinstruct = 'DELIVER IN PERSON') OR (p_partkey = l_partkey AND p_brand = 'Brand#34' AND p_container IN ('LG CASE', 'LG BOX', 'LG PACK', 'LG PKG') AND l_quantity >= 20 AND l_quantity <= 20 + 10 AND p_size BETWEEN 1 AND 15 AND l_shipmode IN ('AIR', 'AIR REG') AND l_shipinstruct = 'DELIVER IN PERSON'); SELECT s_name, s_address FROM supplier, nation WHERE s_suppkey IN ( SELECT ps_suppkey FROM partsupp WHERE ps_partkey IN ( SELECT p_partkey FROM part WHERE p_name LIKE 'forest%') AND ps_availqty > ( SELECT 0.5 * sum(l_quantity) FROM lineitem WHERE l_partkey = ps_partkey AND l_suppkey = ps_suppkey AND l_shipdate >= CAST('1994-01-01' AS date) AND l_shipdate < CAST('1995-01-01' AS date))) AND s_nationkey = n_nationkey AND n_name = 'CANADA' ORDER BY s_name; SELECT s_name, count(*) AS numwait FROM supplier, lineitem l1, orders, nation WHERE s_suppkey = l1.l_suppkey AND o_orderkey = l1.l_orderkey AND o_orderstatus = 'F' AND l1.l_receiptdate > l1.l_commitdate AND EXISTS ( SELECT * FROM lineitem l2 WHERE l2.l_orderkey = l1.l_orderkey AND l2.l_suppkey <> l1.l_suppkey) AND NOT EXISTS ( SELECT * FROM lineitem l3 WHERE l3.l_orderkey = l1.l_orderkey AND l3.l_suppkey <> l1.l_suppkey AND l3.l_receiptdate > l3.l_commitdate) AND s_nationkey = n_nationkey AND n_name = 'SAUDI ARABIA' GROUP BY s_name ORDER BY numwait DESC, s_name LIMIT 100; +SELECT * FROM range(10); +SELECT * FROM range(0, 100); +SELECT * FROM generate_series(0, 10) t(i); diff --git a/test/api/serialized_plans/serialized_plans.binary b/test/api/serialized_plans/serialized_plans.binary index ec497ee84bd..d85bcb9aca3 100644 Binary files a/test/api/serialized_plans/serialized_plans.binary and b/test/api/serialized_plans/serialized_plans.binary differ diff --git a/test/api/test_get_table_names.cpp b/test/api/test_get_table_names.cpp index 9abe4b89075..59a73dd6475 100644 --- a/test/api/test_get_table_names.cpp +++ b/test/api/test_get_table_names.cpp @@ -90,6 +90,11 @@ TEST_CASE("Test GetTableNames", "[api]") { REQUIRE(table_names.size() == 1); REQUIRE(table_names.count("df")); + // generate_series + table_names = con.GetTableNames("with series_generator as (select * from generate_series(TIMESTAMP '2001-04-10', " + "TIMESTAMP '2001-04-11', INTERVAL 1 HOUR)) select * from series_generator"); + REQUIRE(table_names.empty()); + if (!db.ExtensionIsLoaded("tpch")) { return; } diff --git a/test/api/test_reset.cpp b/test/api/test_reset.cpp index 630b971b940..578aa6be2a2 100644 --- a/test/api/test_reset.cpp +++ b/test/api/test_reset.cpp @@ -115,6 +115,7 @@ OptionValueSet &GetValueForOption(const string &name) { {"produce_arrow_string_view", {true}}, {"enable_http_logging", {true}}, {"http_logging_output", {"my_cool_outputfile"}}, + {"produce_arrow_string_view", {true}}, {"allocator_flush_threshold", {"4.0 GiB"}}, {"allocator_background_threads", {true}}}; // Every option that's not excluded has to be part of this map diff --git a/test/appender/test_appender.cpp b/test/appender/test_appender.cpp index 527cbc27a5a..bb659982e2c 100644 --- a/test/appender/test_appender.cpp +++ b/test/appender/test_appender.cpp @@ -169,6 +169,113 @@ TEST_CASE("Test AppendRow", "[appender]") { REQUIRE(CHECK_COLUMN(result, 2, {Value::TIMESTAMP(1992, 1, 1, 1, 1, 1, 0)})); } +TEST_CASE("Test default value appender", "[appender]") { + duckdb::unique_ptr result; + DuckDB db(nullptr); + Connection con(db); + + SECTION("Insert DEFAULT into default column") { + REQUIRE_NO_FAIL(con.Query("CREATE TABLE integers(i iNTEGER, j INTEGER DEFAULT 5)")); + { + Appender appender(con, "integers"); + appender.BeginRow(); + appender.Append(2); + appender.AppendDefault(); + REQUIRE_NOTHROW(appender.EndRow()); + REQUIRE_NOTHROW(appender.Close()); + } + result = con.Query("SELECT * FROM integers"); + REQUIRE(CHECK_COLUMN(result, 0, {Value::INTEGER(2)})); + REQUIRE(CHECK_COLUMN(result, 1, {Value::INTEGER(5)})); + } + + SECTION("Insert DEFAULT into non-default column") { + REQUIRE_NO_FAIL(con.Query("CREATE TABLE integers(i iNTEGER, j INTEGER DEFAULT 5)")); + { + Appender appender(con, "integers"); + appender.BeginRow(); + // 'i' does not have a DEFAULT value, so it gets NULL + REQUIRE_NOTHROW(appender.AppendDefault()); + REQUIRE_NOTHROW(appender.AppendDefault()); + REQUIRE_NOTHROW(appender.EndRow()); + REQUIRE_NOTHROW(appender.Close()); + } + result = con.Query("SELECT * FROM integers"); + REQUIRE(CHECK_COLUMN(result, 0, {Value(LogicalTypeId::INTEGER)})); + REQUIRE(CHECK_COLUMN(result, 1, {Value::INTEGER(5)})); + } + + SECTION("Insert DEFAULT into column that can't be NULL") { + REQUIRE_NO_FAIL(con.Query("CREATE TABLE integers(i integer NOT NULL)")); + { + Appender appender(con, "integers"); + appender.BeginRow(); + REQUIRE_NOTHROW(appender.AppendDefault()); + REQUIRE_NOTHROW(appender.EndRow()); + // NOT NULL constraint failed + REQUIRE_THROWS(appender.Close()); + } + result = con.Query("SELECT * FROM integers"); + auto chunk = result->Fetch(); + REQUIRE(chunk == nullptr); + } + + SECTION("DEFAULT nextval('seq')") { + REQUIRE_NO_FAIL(con.Query("CREATE SEQUENCE seq")); + REQUIRE_NO_FAIL(con.Query("CREATE TABLE integers(i iNTEGER, j INTEGER DEFAULT nextval('seq'))")); + { + Appender appender(con, "integers"); + appender.BeginRow(); + appender.Append(1); + + // NOT_IMPLEMENTED: Non-foldable default values are not supported currently + REQUIRE_THROWS(appender.AppendDefault()); + REQUIRE_THROWS(appender.EndRow()); + REQUIRE_NOTHROW(appender.Close()); + } + // result = con.Query("SELECT * FROM integers"); + // REQUIRE(CHECK_COLUMN(result, 0, {Value::INTEGER(1)})); + // REQUIRE(CHECK_COLUMN(result, 1, {Value::INTEGER(1)})); + } + + SECTION("DEFAULT random()") { + REQUIRE_NO_FAIL(con.Query("CREATE TABLE integers(i iNTEGER, j DOUBLE DEFAULT random())")); + con.Query("select setseed(0.42)"); + { + Appender appender(con, "integers"); + appender.BeginRow(); + appender.Append(1); + // NOT_IMPLEMENTED: Non-foldable default values are not supported currently + REQUIRE_THROWS(appender.AppendDefault()); + REQUIRE_THROWS(appender.EndRow()); + REQUIRE_NOTHROW(appender.Close()); + } + // result = con.Query("SELECT * FROM integers"); + // REQUIRE(CHECK_COLUMN(result, 0, {Value::INTEGER(1)})); + // REQUIRE(CHECK_COLUMN(result, 1, {Value::DOUBLE(0.4729174713138491)})); + } + + SECTION("DEFAULT now()") { + REQUIRE_NO_FAIL(con.Query("CREATE TABLE integers(i iNTEGER, j TIMESTAMPTZ DEFAULT now())")); + con.Query("BEGIN TRANSACTION"); + result = con.Query("select now()"); + auto &materialized_result = result->Cast(); + auto current_time = materialized_result.GetValue(0, 0); + { + Appender appender(con, "integers"); + appender.BeginRow(); + appender.Append(1); + REQUIRE_NOTHROW(appender.AppendDefault()); + REQUIRE_NOTHROW(appender.EndRow()); + REQUIRE_NOTHROW(appender.Close()); + } + result = con.Query("SELECT * FROM integers"); + REQUIRE(CHECK_COLUMN(result, 0, {Value::INTEGER(1)})); + REQUIRE(CHECK_COLUMN(result, 1, {current_time})); + con.Query("COMMIT"); + } +} + TEST_CASE("Test incorrect usage of appender", "[appender]") { duckdb::unique_ptr result; DuckDB db(nullptr); diff --git a/test/extension/load_extension.test b/test/extension/load_extension.test index 5a1fe822ea7..c40b06f929e 100644 --- a/test/extension/load_extension.test +++ b/test/extension/load_extension.test @@ -12,14 +12,17 @@ PRAGMA enable_verification statement error LOAD 'asdf'; ---- +:IO Error: Extension.*not found.* statement error LOAD 'Makefile'; ---- +:IO Error: Extension.*not found.* statement error LOAD NULL; ---- +:Parser Error: syntax error.* statement ok LOAD '__BUILD_DIRECTORY__/test/extension/loadable_extension_demo.duckdb_extension'; @@ -50,10 +53,12 @@ QUACK statement error QUAC ---- +:Parser Error: Did you mean.* statement error QUACK NOT QUACK ---- +:Parser Error: This is not a quack.* query I SELECT contains(loaded_extensions(), 'loadable_extension_demo') diff --git a/test/extension/test_alias_point.test b/test/extension/test_alias_point.test index 4ea6a10ed64..1b95a9360b4 100644 --- a/test/extension/test_alias_point.test +++ b/test/extension/test_alias_point.test @@ -40,10 +40,12 @@ SELECT sub_point(({'x': 2, 'y': 3})::POINT, ({'x': 3, 'y': 4})::POINT) statement error SELECT add_point(pt, pt) from points; ---- +:Binder Error:.*No function matches.* statement error SELECT sub_point(pt, pt) from points; ---- +:Binder Error:.*No function matches.* query I SELECT add_point(point, point) from points; diff --git a/test/fuzzer/duckfuzz/array_hash.test b/test/fuzzer/duckfuzz/array_hash.test index 3d768be6dc0..621d075c072 100644 --- a/test/fuzzer/duckfuzz/array_hash.test +++ b/test/fuzzer/duckfuzz/array_hash.test @@ -18,4 +18,4 @@ SELECT subq_0.c2 AS c4 FROM (SELECT ref_1.fixed_nested_int_array AS c2 FROM main NULL [[4, 5, 6], [NULL, 2, 3], [4, 5, 6]] [[4, 5, 6], [NULL, 2, 3], [4, 5, 6]] -[[NULL, 2, 3], NULL, [NULL, 2, 3]] \ No newline at end of file +[[NULL, 2, 3], NULL, [NULL, 2, 3]] diff --git a/test/fuzzer/duckfuzz/duck_fuzz_column_binding_tests.test b/test/fuzzer/duckfuzz/duck_fuzz_column_binding_tests.test index f55e47d2c6c..eae05e8f33d 100644 --- a/test/fuzzer/duckfuzz/duck_fuzz_column_binding_tests.test +++ b/test/fuzzer/duckfuzz/duck_fuzz_column_binding_tests.test @@ -8,22 +8,20 @@ create table all_types as select * exclude(small_enum, medium_enum, large_enum) # https://github.com/duckdb/duckdb-fuzzer/issues/1357 # simplified query statement ok -SELECT ref_8.uint AS c0, - Argmin(Cast(ref_8."timestamp" AS TIMESTAMP), Cast(ref_10."timestamp" AS TIMESTAMP)) OVER (partition BY ref_10."nested_int_array", ref_10."timestamp" ORDER BY ref_8.hugeint) AS c1 -FROM main.all_types AS ref_8 -INNER JOIN main.all_types AS ref_9 -INNER JOIN main.all_types AS ref_10 -ON ( ref_10.dec38_10 IS NOT NULL) - OR EXISTS - ( SELECT ref_9."float" FROM main.all_types) -ON ((ref_9."smallint" = ref_8."smallint")) - +SELECT ref_8.uint AS c0, + Argmin(Cast(ref_8."timestamp" AS TIMESTAMP), Cast(ref_10."timestamp" AS TIMESTAMP)) OVER (partition BY ref_10."nested_int_array", ref_10."timestamp" ORDER BY ref_8.hugeint) AS c1 +FROM main.all_types AS ref_8 +INNER JOIN main.all_types AS ref_9 +INNER JOIN main.all_types AS ref_10 +ON ( ref_10.dec38_10 IS NOT NULL) + OR EXISTS + ( SELECT ref_9."float" FROM main.all_types) +ON ((ref_9."smallint" = ref_8."smallint")) # original query from fuzzer statement ok SELECT ref_8.uint AS c0, CASE WHEN ((min_by(CAST(ref_8."varchar" AS VARCHAR), CAST(ref_3."varchar" AS VARCHAR)) OVER (PARTITION BY subq_3.c1, ref_10.double_array ORDER BY ref_7."varchar") ~~* ref_10."varchar")) THEN (argmin(CAST(ref_6."timestamp" AS TIMESTAMP), CAST(ref_10."timestamp" AS TIMESTAMP)) OVER (PARTITION BY ref_10.nested_int_array, ref_10."timestamp" ORDER BY ref_8.hugeint)) ELSE argmin(CAST(ref_6."timestamp" AS TIMESTAMP), CAST(ref_10."timestamp" AS TIMESTAMP)) OVER (PARTITION BY ref_10.nested_int_array, ref_10."timestamp" ORDER BY ref_8.hugeint) END AS c1 FROM main.all_types AS ref_0 INNER JOIN (SELECT ref_1.timestamp_array AS c1 FROM main.all_types AS ref_1 INNER JOIN main.all_types AS ref_2 ON (NULL) WHERE (((CAST(NULL AS VARCHAR) ~~~ CAST(NULL AS VARCHAR)) OR (ref_1.blob IS NOT NULL) OR 0) AND (ref_1.timestamp_ms IS NULL) AND ((SELECT histogram("varchar") FROM main.all_types) IS NOT NULL) AND ((ref_2.timestamp_s IS NULL) OR (((ref_2."varchar" ~~~ ref_1."varchar") OR 1 OR (ref_2."varchar" ~~ (SELECT "varchar" FROM main.all_types LIMIT 1 OFFSET 5))) AND (ref_2."varchar" ~~ ref_2."varchar")) OR ((SELECT "varchar" FROM main.all_types LIMIT 1 OFFSET 6) !~~* ref_1."varchar")))) AS subq_0 ON (ref_0."varchar") LEFT JOIN main.all_types AS ref_3 LEFT JOIN (SELECT ref_4.ubigint AS c0, 13 AS c1, ref_4."time" AS c2, ref_4."float" AS c3, (SELECT double_array FROM main.all_types LIMIT 1 OFFSET 6) AS c4 FROM main.all_types AS ref_4 WHERE NULL) AS subq_1 ON ((ref_3."float" = subq_1.c3)) ON (NULL) INNER JOIN (SELECT ref_5.timestamp_ms AS c4 FROM main.all_types AS ref_5) AS subq_2 LEFT JOIN main.all_types AS ref_6 INNER JOIN main.all_types AS ref_7 ON (((SELECT "varchar" FROM main.all_types LIMIT 1 OFFSET 1) ~~* ref_7."varchar")) INNER JOIN main.all_types AS ref_8 INNER JOIN main.all_types AS ref_9 INNER JOIN main.all_types AS ref_10 ON (((ref_9."varchar" !~~* ref_9."varchar") OR (ref_10.dec38_10 IS NOT NULL) OR EXISTS(SELECT ref_9."float" AS c0, ref_9.usmallint AS c1, ref_10."bigint" AS c2, (SELECT bool FROM main.all_types LIMIT 1 OFFSET 5) AS c3, ref_10.nested_int_array AS c4, ref_9.timestamp_ms AS c5, 4 AS c6, ref_11."map" AS c7, (SELECT uint FROM main.all_types LIMIT 1 OFFSET 3) AS c8, ref_9.dec_4_1 AS c9 FROM main.all_types AS ref_11 WHERE (1 AND EXISTS(SELECT ref_10.varchar_array AS c0 FROM main.all_types AS ref_12 WHERE 0 LIMIT 149) AND 1) LIMIT 180))) ON (EXISTS(SELECT ref_8.double_array AS c0, ref_10."timestamp" AS c1, ref_8.uuid AS c2, ref_13.dec_9_4 AS c3, ref_13."int" AS c4, ref_13.timestamp_ns AS c5, ref_8."float" AS c6, 63 AS c7 FROM main.all_types AS ref_13 WHERE (ref_13."varchar" ~~ ref_9."varchar"))) ON ((ref_7."smallint" = ref_8."smallint")) INNER JOIN (SELECT ref_14."interval" AS c1 FROM main.all_types AS ref_14 WHERE ref_14."varchar") AS subq_3 ON (EXISTS(SELECT ref_15.utinyint AS c0 FROM main.all_types AS ref_15 WHERE (ref_9."varchar" ~~* (SELECT "varchar" FROM main.all_types LIMIT 1 OFFSET 4)))) ON ((ref_9."varchar" !~~ ref_6."varchar")) ON ((ref_3.timestamp_array = ref_6.timestamp_array)) - # https://github.com/duckdb/duckdb-fuzzer/issues/1358 statement ok SELECT subq_0.c6 AS c1, subq_0.c14 AS c2, subq_0.c7 AS c4, subq_0.c4 AS c5 FROM (SELECT (SELECT date FROM main.all_types LIMIT 1 OFFSET 6) AS c3, ref_2."time" AS c4, (SELECT uuid FROM main.all_types LIMIT 1 OFFSET 1) AS c5, ref_3.array_of_structs AS c6, CASE WHEN (((ref_0."varchar" !~~* ref_1."varchar") OR (ref_5."varchar" ~~~ ref_6."varchar"))) THEN (ref_2."bigint") ELSE ref_2."bigint" END AS c7, rtrim(CAST(CASE WHEN ((((ref_8."varchar" ~~~ ref_2."varchar") AND (ref_2."varchar" ~~~ ref_0."varchar")) OR (1 AND (ref_7."varchar" ~~ ref_2."varchar")))) THEN (ref_8."varchar") ELSE ref_8."varchar" END AS VARCHAR), CAST(ref_2."varchar" AS VARCHAR)) AS c9, ref_8.ubigint AS c14 FROM main.all_types AS ref_0 INNER JOIN main.all_types AS ref_1 INNER JOIN main.all_types AS ref_2 ON ((ref_1.int_array = ref_2.int_array)) ON (((ref_2."varchar" !~~ ref_1."varchar") OR (ref_1.blob IS NOT NULL))) INNER JOIN main.all_types AS ref_3 INNER JOIN main.all_types AS ref_4 RIGHT JOIN main.all_types AS ref_5 ON ((ref_4.dec_18_6 = ref_5.dec_18_6)) ON (ref_5."varchar") LEFT JOIN main.all_types AS ref_6 RIGHT JOIN main.all_types AS ref_7 INNER JOIN main.all_types AS ref_8 ON ((ref_7.timestamp_array = ref_8.timestamp_array)) ON (1) ON (NULL) ON ((ref_0.dec_18_6 = ref_3.dec_18_6)) WHERE (ref_5."varchar" ^@ (SELECT "varchar" FROM main.all_types LIMIT 1 OFFSET 6)) LIMIT 96) AS subq_0 WHERE subq_0.c9 diff --git a/test/fuzzer/duckfuzz/duckfuzz_tests/test_duckfuzz.test b/test/fuzzer/duckfuzz/duckfuzz_tests/test_duckfuzz.test deleted file mode 100644 index 55073d30eb9..00000000000 --- a/test/fuzzer/duckfuzz/duckfuzz_tests/test_duckfuzz.test +++ /dev/null @@ -1,16 +0,0 @@ -# name: test/fuzzer/duckfuzz/duckfuzz_tests/test_duckfuzz.test -# description: Invalid make time -# group: [duckfuzz_tests] - -# To run these tests make remove require not_available -require not_available - -require sqlsmith - -loop i 1000 2000 - -statement ok -call fuzzyduck(max_queries=1, seed=${i}, verbose_output=1); - -endloop - diff --git a/test/fuzzer/duckfuzz/generate_null_timestamp.test b/test/fuzzer/duckfuzz/generate_null_timestamp.test index d3546fe5311..d2b7125dad4 100644 --- a/test/fuzzer/duckfuzz/generate_null_timestamp.test +++ b/test/fuzzer/duckfuzz/generate_null_timestamp.test @@ -5,8 +5,7 @@ statement ok PRAGMA enable_verification -statement error +query I SELECT NULL FROM generate_series(CAST('294247-01-10 04:00:54.775806' AS TIMESTAMP), NULL, NULL) AS t3(c1, c2) ---- -RANGE with NULL argument is not supported diff --git a/test/fuzzer/pedro/nested_subquery_table_function.test b/test/fuzzer/pedro/nested_subquery_table_function.test index 99f53f4b3e1..b20737af107 100644 --- a/test/fuzzer/pedro/nested_subquery_table_function.test +++ b/test/fuzzer/pedro/nested_subquery_table_function.test @@ -5,10 +5,18 @@ statement ok PRAGMA enable_verification -statement error +query I SELECT 1 FROM range((SELECT 1) - 0); ---- +1 -statement error +query I SELECT (SELECT 1 FROM range((SELECT 1) - 0)); ---- +1 + +query I +FROM range((SELECT 3) - 1) +---- +0 +1 diff --git a/test/fuzzer/sqlsmith/timestamptz_null_range.test b/test/fuzzer/sqlsmith/timestamptz_null_range.test index 1d44b7c1ab5..2425c3e89a9 100644 --- a/test/fuzzer/sqlsmith/timestamptz_null_range.test +++ b/test/fuzzer/sqlsmith/timestamptz_null_range.test @@ -6,7 +6,10 @@ require icu require no_extension_autoloading -statement error +statement ok +PRAGMA enable_verification + +query I SELECT NULL FROM ( SELECT 4767 FROM generate_series(CAST('290309-12-22 (BC) 00:00:00+00' AS TIMESTAMP WITH TIME ZONE), NULL, NULL) @@ -14,4 +17,3 @@ SELECT NULL FROM ( ) AS t64 ---- -RANGE with NULL bounds is not supported diff --git a/test/issues/general/test_5614.test b/test/issues/general/test_5614.test index e03778fed51..7eb5ff6e5f4 100644 --- a/test/issues/general/test_5614.test +++ b/test/issues/general/test_5614.test @@ -2,6 +2,9 @@ # description: Issue 5614: # group: [general] +statement ok +pragma enable_verification + statement ok create table t0 as select (UNNEST(['hello', 'duckdb', 'duck LORD', 'lord duck'])) as column0; diff --git a/test/optimizer/column_lifetime_analyzer/must_visit_operator_expressions_first.test b/test/optimizer/column_lifetime_analyzer/must_visit_operator_expressions_first.test new file mode 100644 index 00000000000..5965e3b7af4 --- /dev/null +++ b/test/optimizer/column_lifetime_analyzer/must_visit_operator_expressions_first.test @@ -0,0 +1,19 @@ +# name: test/optimizer/column_lifetime_analyzer/must_visit_operator_expressions_first.test +# description: Test column lifetime analyzer +# group: [column_lifetime_analyzer] + +statement ok +create table t5 as select (range + 1000) a5, range b5, (range + 50)::INT::VARCHAR || '__suffix__' c5 from range(50); + +statement ok +create table t1 as select range::INT a1, (range + 45)::INT b1, (range)::INT::VARCHAR || '__suffix__' c1 from range(900); + + +query II +select a5, c1 from t1, t5 where b5=b1; +---- +1045 0__suffix__ +1046 1__suffix__ +1047 2__suffix__ +1048 3__suffix__ +1049 4__suffix__ diff --git a/test/optimizer/deliminator.test b/test/optimizer/deliminator.test index cf450051949..de5233c94b8 100644 --- a/test/optimizer/deliminator.test +++ b/test/optimizer/deliminator.test @@ -31,6 +31,7 @@ explain SELECT sum(l_extendedprice) / 7.0 AS avg_yearly FROM lineitem, part WHER ---- logical_opt :.*DELIM_JOIN.* + # Q 20: join with JoinType::SINGLE (created when pushing down dependent joins) is converted to LEFT query II explain SELECT s_name, s_address FROM supplier, nation WHERE s_suppkey IN ( SELECT ps_suppkey FROM partsupp WHERE ps_partkey IN ( SELECT p_partkey FROM part WHERE p_name LIKE 'forest%') AND ps_availqty > ( SELECT 0.5 * sum(l_quantity) FROM lineitem WHERE l_partkey = ps_partkey AND l_suppkey = ps_suppkey AND l_shipdate >= CAST('1994-01-01' AS date) AND l_shipdate < CAST('1995-01-01' AS date))) AND s_nationkey = n_nationkey AND n_name = 'CANADA' ORDER BY s_name; diff --git a/test/optimizer/join_dependent_filter.test b/test/optimizer/join_dependent_filter.test index dbf32014a60..6712efabe39 100644 --- a/test/optimizer/join_dependent_filter.test +++ b/test/optimizer/join_dependent_filter.test @@ -235,7 +235,7 @@ ORDER BY physical_plan :.*FILTER.*FILTER.*FILTER.* # results should still be the same -query I +query IIII PRAGMA tpch(7) ---- :extension/tpch/dbgen/answers/sf0.01/q07.csv diff --git a/test/optimizer/joins/pushdown_semi_anti.test b/test/optimizer/joins/pushdown_semi_anti.test new file mode 100644 index 00000000000..6decef39690 --- /dev/null +++ b/test/optimizer/joins/pushdown_semi_anti.test @@ -0,0 +1,29 @@ +# name: test/optimizer/joins/pushdown_semi_anti.test +# description: Verify semi anti joins are pushed down +# group: [joins] + +statement ok +create table tbl1 as select range a from range(10000); + +statement ok +create table tbl2 as select range b from range(1000); + +statement ok +create table tbl3 as select range c from range(100); + +statement ok +set disabled_optimizers='statistics_propagation'; + +query II +EXPLAIN select * from tbl1, tbl2 where b in (select * from tbl3) and tbl1.a = tbl2.b; +---- +physical_plan :.*INNER.*SEMI.* + +statement ok +set disabled_optimizers='statistics_propagation,join_order'; + +# make sure non-optimized plan has semi on top of the inner +query II +EXPLAIN select * from tbl1, tbl2 where b in (select * from tbl3) and tbl1.a = tbl2.b; +---- +physical_plan :.*SEMI.*INNER.* diff --git a/test/optimizer/perfect_ht.test b/test/optimizer/perfect_ht.test index daf408e8275..9ce52eb56eb 100644 --- a/test/optimizer/perfect_ht.test +++ b/test/optimizer/perfect_ht.test @@ -51,7 +51,9 @@ physical_plan :.*PERFECT_HASH_GROUP_BY.* statement error PRAGMA perfect_ht_threshold=-1; ---- +:Parser Error:.*out of range.* statement error PRAGMA perfect_ht_threshold=100; ---- +:Parser Error:.*out of range.* \ No newline at end of file diff --git a/test/optimizer/statistics/statistics_case.test b/test/optimizer/statistics/statistics_case.test index c3fe5c59a23..0aaa0367dba 100644 --- a/test/optimizer/statistics/statistics_case.test +++ b/test/optimizer/statistics/statistics_case.test @@ -28,6 +28,7 @@ logical_opt :.*EMPTY_RESULT.* statement error SELECT 123::TINYINT + (CASE WHEN i=2 THEN (i+1)::TINYINT ELSE (i+2)::TINYINT END) FROM integers; ---- +:Out of Range Error:.*Overflow in addition.* # this does not query I diff --git a/test/sql/aggregate/aggregates/test_approximate_distinct_count.test b/test/sql/aggregate/aggregates/test_approximate_distinct_count.test index c9cc5fa0f3d..bd9b8bf43d9 100644 --- a/test/sql/aggregate/aggregates/test_approximate_distinct_count.test +++ b/test/sql/aggregate/aggregates/test_approximate_distinct_count.test @@ -62,13 +62,13 @@ create table t as select range a, mod(range,10) b from range(2000); query III SELECT COUNT( a),approx_count_distinct(a),approx_count_distinct(b) from t ---- -2000 1991 10 +2000 2322 11 query I SELECT approx_count_distinct(a) from t group by a %2 order by all; ---- -986 -993 +1006 +1230 query I SELECT count(*) from t where a < 10; @@ -92,7 +92,7 @@ SELECT approx_count_distinct(a) over (partition by a%2) from t where a < 10; query II SELECT COUNT( t),approx_count_distinct(t) from timestamp ---- -7 7 +7 6 query II SELECT COUNT( t),approx_count_distinct(t) from dates diff --git a/test/sql/attach/attach_read_only_transaction.test b/test/sql/attach/attach_read_only_transaction.test new file mode 100644 index 00000000000..b5ab4949f42 --- /dev/null +++ b/test/sql/attach/attach_read_only_transaction.test @@ -0,0 +1,33 @@ +# name: test/sql/attach/attach_read_only_transaction.test +# description: Test attach with explicit READ ONLY transactions +# group: [attach] + +require skip_reload + +statement ok +PRAGMA enable_verification + +statement ok +ATTACH ':memory:' AS db1; + +statement ok +CREATE TABLE db1.integers(i INTEGER); + +statement ok +INSERT INTO db1.integers VALUES (42); + +statement ok +BEGIN TRANSACTION READ ONLY + +query I +FROM db1.integers +---- +42 + +statement error +INSERT INTO db1.integers VALUES (48) +---- +transaction is launched in read-only mode + +statement ok +COMMIT \ No newline at end of file diff --git a/test/sql/attach/attach_remote.test b/test/sql/attach/attach_remote.test new file mode 100644 index 00000000000..4b5b9e40cee --- /dev/null +++ b/test/sql/attach/attach_remote.test @@ -0,0 +1,10 @@ +# name: test/sql/attach/attach_remote.test +# description: Test attaching of remote database +# group: [attach] + +require httpfs + +statement error +ATTACH 'https://duckdb.org/non_existing.db' AS db2 (READ_ONLY) +---- +IO Error: Cannot open database "https://duckdb.org/non_existing.db" in read-only mode: database does not exist diff --git a/test/sql/attach/attach_s3_tpch.test_slow b/test/sql/attach/attach_s3_tpch.test_slow index 76f895cad61..68a1cb2bda0 100644 --- a/test/sql/attach/attach_s3_tpch.test_slow +++ b/test/sql/attach/attach_s3_tpch.test_slow @@ -55,3 +55,20 @@ PRAGMA tpch(${i}) :extension/tpch/dbgen/answers/sf1/q${i}.csv endloop + +statement ok +USE memory + +statement ok +DETACH db + +statement ok +ATTACH 's3://test-bucket/presigned/lineitem_sf1.db' AS db (READONLY 1); + +statement ok +USE db + +query IIIIIIIIIIIIIIII +select count(distinct columns(*)) from lineitem; +---- +1500000 200000 10000 7 50 933900 11 9 3 2 2526 2466 2554 4 7 3610733 diff --git a/test/sql/copy/csv/read_csv_subquery.test b/test/sql/copy/csv/read_csv_subquery.test index 0eb5c1576fd..5b59510ffbe 100644 --- a/test/sql/copy/csv/read_csv_subquery.test +++ b/test/sql/copy/csv/read_csv_subquery.test @@ -14,7 +14,7 @@ FROM read_csv_auto((SELECT url FROM urls LIMIT 3), delim=',') WHERE properties.height > -1.0 LIMIT 10 ---- -Only table-in-out functions can have subquery parameters +subqueries statement error SELECT * diff --git a/test/sql/copy/csv/test_lineitem_gz.test b/test/sql/copy/csv/test_lineitem_gz.test new file mode 100644 index 00000000000..45d10ff86ee --- /dev/null +++ b/test/sql/copy/csv/test_lineitem_gz.test @@ -0,0 +1,38 @@ +# name: test/sql/copy/csv/test_lineitem_gz.test +# description: Test small memory limit on gzipped csv files +# group: [csv] + +# No way CI can handle this +mode skip + +statement ok +PRAGMA enable_verification + + +require tpch + +statement ok +CALL dbgen(sf=10); + +statement ok +copy lineitem to '__TEST_DIR__/lineitem1.csv.gz' + +statement ok +set memory_limit='32gb'; + +# Run it over 50 TPCHs +query I +select count(*) from read_csv([ +'__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz', +'__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz', +'__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz', +'__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz', +'__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz', +'__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz', +'__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz', +'__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz', +'__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz', +'__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz','__TEST_DIR__/lineitem1.csv.gz' +]); +---- +0 \ No newline at end of file diff --git a/test/sql/copy/csv/test_skip.test b/test/sql/copy/csv/test_skip.test_slow similarity index 57% rename from test/sql/copy/csv/test_skip.test rename to test/sql/copy/csv/test_skip.test_slow index 1508f6e1849..a3ae8ff7eca 100644 --- a/test/sql/copy/csv/test_skip.test +++ b/test/sql/copy/csv/test_skip.test_slow @@ -1,4 +1,4 @@ -# name: test/sql/copy/csv/test_skip.test +# name: test/sql/copy/csv/test_skip.test_slow # description: Test that the skip option works for csv files # group: [csv] @@ -8,6 +8,7 @@ PRAGMA enable_verification statement ok copy (from range(10000)) to '__TEST_DIR__/skip.csv' (HEADER 0); + foreach auto_detect true false # Test -1 @@ -67,14 +68,10 @@ SELECT * EXCLUDE (prompt) from sniff_csv('__TEST_DIR__/skip.csv',skip=3000) query IIIIIIIIII SELECT * EXCLUDE (prompt) from sniff_csv('__TEST_DIR__/skip.csv',skip=11000) ---- -, " " \n 11000 0 [{'name': column0, 'type': VARCHAR}] NULL NULL skip=11000 +, " " \n 11000 0 [{'name': column0, 'type': BIGINT}] NULL NULL skip=11000 # Test with different buffer sizes -# There is currently a limitation on skip if the number of rows to be skipped go over a buffer boundary - -mode skip - loop buffer_size 5 10 # Test -1 @@ -123,4 +120,165 @@ select count(*) from read_csv('__TEST_DIR__/skip.csv', skip=11000, buffer_size=$ ---- 0 -endloop \ No newline at end of file +endloop + +# Now lets test a csv file with many lines of notes +statement ok +create table t (a varchar) + +statement ok +insert into t select '#This is a comment' from range(10000) + +statement ok +insert into t select '1,2,3' from range(10) + +statement ok +copy t to '__TEST_DIR__/skip_2.csv' (HEADER 0, delim ';'); + + +query III +from read_csv('__TEST_DIR__/skip_2.csv',skip=10000, buffer_size = 26) +---- +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 + +query IIIIIIIIII +SELECT * EXCLUDE (prompt) from sniff_csv('__TEST_DIR__/skip_2.csv',skip=10000) +---- +, " " \n 10000 0 [{'name': column0, 'type': BIGINT}, {'name': column1, 'type': BIGINT}, {'name': column2, 'type': BIGINT}] NULL NULL skip=10000 + +query III +from read_csv('__TEST_DIR__/skip_2.csv',skip=10000) +---- +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 + +loop buffer_size 20 25 + +query III +from read_csv('__TEST_DIR__/skip_2.csv',skip=10000, buffer_size = ${buffer_size}) +---- +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 + +endloop + +# Multifile Testing + +query III +from read_csv(['__TEST_DIR__/skip_2.csv','__TEST_DIR__/skip_2.csv','__TEST_DIR__/skip_2.csv'],skip=10000, buffer_size = 26) +---- +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 + +query III +from read_csv(['__TEST_DIR__/skip_2.csv','__TEST_DIR__/skip_2.csv','__TEST_DIR__/skip_2.csv'],skip=10000) +---- +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 +1 2 3 + +require tpch + +statement ok +CALL dbgen(sf=0.1); + +# Lineitem has about 75 mb +statement ok +COPY lineitem TO '__TEST_DIR__/lineitem.csv' (DELIMITER '|', HEADER); + +# Lets check skipping ~ 15 mb +query I +select count(*) from read_csv('__TEST_DIR__/lineitem.csv') +---- +600572 + +query I +select count(*) from read_csv('__TEST_DIR__/lineitem.csv', skip=158310) +---- +442263 + +# Lets check skipping ~ 40 mb +query I +select count(*) from read_csv('__TEST_DIR__/lineitem.csv', skip=474930) +---- +125643 \ No newline at end of file diff --git a/test/sql/copy/partitioned/hive_partition_append.test b/test/sql/copy/partitioned/hive_partition_append.test new file mode 100644 index 00000000000..a9869b71993 --- /dev/null +++ b/test/sql/copy/partitioned/hive_partition_append.test @@ -0,0 +1,63 @@ +# name: test/sql/copy/partitioned/hive_partition_append.test +# description: test APPEND mode for hive partitioned write +# group: [partitioned] + +require parquet + +statement ok +CREATE TABLE sensor_data(ts TIMESTAMP, value INT); + +statement ok +INSERT INTO sensor_data VALUES + (TIMESTAMP '2000-01-01 01:02:03', 42), + (TIMESTAMP '2000-02-01 01:02:03', 100), + (TIMESTAMP '2000-03-01 12:11:10', 1000) +; + +statement ok +COPY (SELECT YEAR(ts) AS year, MONTH(ts) AS month, * FROM sensor_data) +TO '__TEST_DIR__/partitioned_append' (FORMAT PARQUET, PARTITION_BY (year, month), APPEND); + +query III +SELECT year, month, SUM(value) FROM '__TEST_DIR__/partitioned_append/**/*.parquet' GROUP BY ALL ORDER BY ALL +---- +2000 1 42 +2000 2 100 +2000 3 1000 + +statement ok +DELETE FROM sensor_data; + +statement ok +INSERT INTO sensor_data VALUES + (TIMESTAMP '2000-01-01 02:02:03', 62), + (TIMESTAMP '2000-03-01 13:11:10', 50) +; + +statement ok +COPY (SELECT YEAR(ts) AS year, MONTH(ts) AS month, * FROM sensor_data) +TO '__TEST_DIR__/partitioned_append' (FORMAT PARQUET, PARTITION_BY (year, month), APPEND, FILENAME_PATTERN 'my_pattern_{uuid}'); + +query III +SELECT year, month, SUM(value) FROM '__TEST_DIR__/partitioned_append/**/*.parquet' GROUP BY ALL ORDER BY ALL +---- +2000 1 104 +2000 2 100 +2000 3 1050 + +statement ok +COPY (SELECT YEAR(ts) AS year, MONTH(ts) AS month, * FROM sensor_data) +TO '__TEST_DIR__/partitioned_append' (FORMAT PARQUET, PARTITION_BY (year, month), FILENAME_PATTERN 'my_pattern_{uuid}', APPEND); + +query III +SELECT year, month, SUM(value) FROM '__TEST_DIR__/partitioned_append/**/*.parquet' GROUP BY ALL ORDER BY ALL +---- +2000 1 166 +2000 2 100 +2000 3 1100 + +statement error +COPY (SELECT YEAR(ts) AS year, MONTH(ts) AS month, * FROM sensor_data) +TO '__TEST_DIR__/partitioned_append' (FORMAT PARQUET, PARTITION_BY (year, month), APPEND, FILENAME_PATTERN 'my_pattern_without_uuid'); +---- +APPEND mode requires a {uuid} label in filename_pattern diff --git a/test/sql/copy/partitioned/hive_partitioning_overwrite.test b/test/sql/copy/partitioned/hive_partitioning_overwrite.test index eb002273aa4..4035c38c34c 100644 --- a/test/sql/copy/partitioned/hive_partitioning_overwrite.test +++ b/test/sql/copy/partitioned/hive_partitioning_overwrite.test @@ -44,4 +44,4 @@ SELECT * FROM '__TEST_DIR__/overwrite_test2/**/*.parquet' statement error COPY (SELECT 84 AS part_col) TO '__TEST_DIR__/overwrite_test' (FORMAT PARQUET, PARTITION_BY (part_col), OVERWRITE 1, OVERWRITE_OR_IGNORE 1); ---- -Can only set one of OVERWRITE_OR_IGNORE or OVERWRITE +OVERWRITE diff --git a/test/sql/copy/per_thread_output.test b/test/sql/copy/per_thread_output.test index da8ed9371b6..0efcf832842 100644 --- a/test/sql/copy/per_thread_output.test +++ b/test/sql/copy/per_thread_output.test @@ -54,10 +54,10 @@ SELECT COUNT(*) FROM PARQUET_SCAN('__TEST_DIR__/per_thread_output2/*.parquet') 10000 -# cant write to existing folders statement error COPY (FROM bigdata) TO '__TEST_DIR__/per_thread_output2/' (FORMAT PARQUET, PER_THREAD_OUTPUT TRUE); ---- +IO Error # we have not added anything query I @@ -66,7 +66,7 @@ SELECT COUNT(*) FROM PARQUET_SCAN('__TEST_DIR__/per_thread_output2/*.parquet') 10000 -# this should not work statement error COPY (FROM bigdata) TO '__TEST_DIR__/per_thread_output3' (FORMAT PARQUET, PER_THREAD_OUTPUT TRUE, USE_TMP_FILE TRUE); ---- +Not implemented Error \ No newline at end of file diff --git a/test/sql/copy/return_files.test b/test/sql/copy/return_files.test new file mode 100644 index 00000000000..8c815bc4e9d --- /dev/null +++ b/test/sql/copy/return_files.test @@ -0,0 +1,45 @@ +# name: test/sql/copy/return_files.test +# description: test RETURN_FILES parameter for COPY +# group: [copy] + +require parquet + +statement ok +CREATE TABLE integers AS SELECT range i FROM range(200000); + +statement ok +SET preserve_insertion_order=false; + +query II +COPY integers TO '__TEST_DIR__/test_copy_to_file.parquet' (RETURN_FILES); +---- +200000 :.*test_copy_to_file.parquet.* + +statement ok +SET preserve_insertion_order=true; + +query II +COPY integers TO '__TEST_DIR__/test_batch_copy_to_file.parquet' (RETURN_FILES TRUE); +---- +200000 :.*test_batch_copy_to_file.parquet.* + +statement ok +SET threads=2; + +query II +COPY integers TO '__TEST_DIR__/test_per_thread_output' (RETURN_FILES, PER_THREAD_OUTPUT); +---- +200000 :.*data_0.csv.*data_1.csv.* + +require notwindows + +statement ok +SET threads=1; + +statement ok +CREATE TABLE integers2 AS SELECT range i, range % 4 j FROM range(200000); + +query II +COPY integers2 TO '__TEST_DIR__/test_partition_by' (RETURN_FILES TRUE, PARTITION_BY j); +---- +200000 :.*test_partition_by/j=0/data_0.csv.*test_partition_by/j=1/data_0.csv.*test_partition_by/j=2/data_0.csv.*test_partition_by/j=3/data_0.csv.* diff --git a/test/sql/cte/materialized/test_cte_in_cte_materialized.test b/test/sql/cte/materialized/test_cte_in_cte_materialized.test index a6587af9b63..0c7aa484ed3 100644 --- a/test/sql/cte/materialized/test_cte_in_cte_materialized.test +++ b/test/sql/cte/materialized/test_cte_in_cte_materialized.test @@ -48,6 +48,11 @@ with cte1 as MATERIALIZED (Select i as j from a) select * from cte1 where j = (w ---- 42 +query I +with cte as materialized (Select i as j from a) select * from cte where j = (with cte as (select max(j) as j from cte) select j from cte); +---- +42 + require noalternativeverify # refer to same-named CTE in a subquery expression diff --git a/test/sql/fts/issue_12330.test b/test/sql/fts/issue_12330.test new file mode 100644 index 00000000000..60433e1bc94 --- /dev/null +++ b/test/sql/fts/issue_12330.test @@ -0,0 +1,34 @@ +# name: test/sql/fts/issue_12330.test +# description: Issue 12330: BM25 matching scores seems to be invalid +# group: [fts] + +# issue #7384 and #8141 + +require fts + +statement ok +CREATE OR REPLACE TABLE documents ( + id VARCHAR, + content VARCHAR +); + +statement ok +INSERT INTO documents VALUES + ('doc1', 'DuckDB database lorem'), + ('doc2', 'DuckDB database ipsum'), + ('doc3', 'DuckDB database ipsum dolor'); + +statement ok +PRAGMA create_fts_index('documents', 'id', 'content'); + +query I +SELECT + id +FROM + documents +ORDER BY + fts_main_documents.match_bm25(id, 'DuckDB database ipsum') DESC; +---- +doc2 +doc3 +doc1 diff --git a/test/sql/fts/test_indexing.test_slow b/test/sql/fts/test_indexing.test_slow index bc99f0e0298..7ff6928d1a9 100644 --- a/test/sql/fts/test_indexing.test_slow +++ b/test/sql/fts/test_indexing.test_slow @@ -135,8 +135,8 @@ doc1 0.36835264087244074 query III SELECT score, id, body FROM (SELECT *, fts_main_documents.match_bm25(id, 'quacked barked') AS score FROM documents) sq WHERE score IS NOT NULL ORDER BY score DESC ---- -0.37543634550460314 doc2 BÁRKING+BÁRKING+BÁRKING+BÁRKING -0.3683526408724408 doc1 QUÁCKING+QUÁCKING+QUÁCKING +0.7208701623069375 doc2 BÁRKING+BÁRKING+BÁRKING+BÁRKING +0.7072688384898254 doc1 QUÁCKING+QUÁCKING+QUÁCKING # drop and re-create, but index both the 'body' and 'author' column this time statement ok diff --git a/test/sql/fts/test_issue_10254.test b/test/sql/fts/test_issue_10254.test index 0d5cd0cef1b..fd149745a10 100644 --- a/test/sql/fts/test_issue_10254.test +++ b/test/sql/fts/test_issue_10254.test @@ -21,5 +21,5 @@ PRAGMA create_fts_index('data', 'id', 'context', 'question', stemmer='russian', query I SELECT id FROM (SELECT *, fts_main_data.match_bm25(id, 'Какие') AS score FROM data) sq WHERE score IS NOT NULL ORDER BY score DESC; ---- -1 0 +1 diff --git a/test/sql/function/list/aggregates/approx_count_distinct.test b/test/sql/function/list/aggregates/approx_count_distinct.test index d1258b0c755..110006f9a71 100644 --- a/test/sql/function/list/aggregates/approx_count_distinct.test +++ b/test/sql/function/list/aggregates/approx_count_distinct.test @@ -56,7 +56,7 @@ INSERT INTO timestamp VALUES (['2008-01-01 00:00:01', NULL, '2007-01-01 00:00:01 query II SELECT list_count(t), list_approx_count_distinct(t) from timestamp ---- -7 7 +7 6 # strings statement ok @@ -80,7 +80,7 @@ INSERT INTO list_ints_2 SELECT LIST(a), LIST(mod(a, 10)) FROM range(2000) tbl(a) query III SELECT list_count(a), list_approx_count_distinct(a), list_approx_count_distinct(b) from list_ints_2 ---- -2000 1991 10 +2000 2322 11 statement ok DELETE FROM list_ints_2 @@ -94,5 +94,5 @@ INSERT INTO list_ints_2 SELECT LIST(a), NULL FROM range(2000) tbl(a, b) WHERE a query I SELECT list_approx_count_distinct(a) from list_ints_2; ---- -993 -986 +1006 +1230 diff --git a/test/sql/function/string/test_concat.test b/test/sql/function/string/test_concat.test index 9fdaefe4cc7..0a0a5f1d1d0 100644 --- a/test/sql/function/string/test_concat.test +++ b/test/sql/function/string/test_concat.test @@ -81,4 +81,3 @@ SELECT CONCAT('hello', ' ', s) FROM strings ORDER BY s hello hello hello hello world - diff --git a/test/sql/function/string/test_concat_binding.test b/test/sql/function/string/test_concat_binding.test new file mode 100644 index 00000000000..7904df568af --- /dev/null +++ b/test/sql/function/string/test_concat_binding.test @@ -0,0 +1,69 @@ +# name: test/sql/function/string/test_concat_binding.test +# description: Test the binding of the concat function +# group: [string] + +statement ok +PRAGMA enable_verification + +statement ok +SET default_null_order='nulls_first'; + +query I +select [1] || [2]; +---- +[1, 2] + +query I +select [1] || NULL; +---- +NULL + +query I +select list_concat([1], NULL); +---- +[1] + +query I +SELECT CONCAT('hello') +---- +hello + +query I +select array[1] || array[2]; +---- +[1, 2] + +query I +select array[1] || array[NULL]; +---- +[1, NULL] + +query I +select list_concat(array[1], array[NULL]); +---- +[1, NULL] + +query I +select array[1] || cast(NULL as int array); +---- +NULL + +statement error +select concat([1], 'hello'); +---- +Binder Error: Cannot concatenate types INTEGER[] and VARCHAR + +query I +select 'hi' || NULL; +---- +NULL + +statement error +select list_concat([1], [2], [3]); +---- +Binder Error: No function matches the given name and argument types 'list_concat(INTEGER[], INTEGER[], INTEGER[])'. + +query I +select [1] || [2] || [3]; +---- +[1, 2, 3] diff --git a/test/sql/function/timestamp/test_icu_strptime.test b/test/sql/function/timestamp/test_icu_strptime.test index c6de0be1894..ff9c14ca4f7 100644 --- a/test/sql/function/timestamp/test_icu_strptime.test +++ b/test/sql/function/timestamp/test_icu_strptime.test @@ -421,6 +421,96 @@ ORDER BY ALL 2022-03-05 20:59:17.877-08 Pacific/Niue 2022-03-05 21:59:17.877-08 Etc/GMT+12 +# First has no TZ +query II +SELECT ${func}('2022-03-05 17:59:17.877 ' || tz_name, ['%Y-%m-%d %H:%M:%S.%g', '%Y-%m-%d %H:%M:%S.%g %Z']) tstz, tz_name +FROM zones +ORDER BY ALL +---- +2022-03-04 19:59:17.877-08 Etc/GMT-14 +2022-03-04 20:14:17.877-08 NZ-CHAT +2022-03-04 20:59:17.877-08 Pacific/Auckland +2022-03-04 20:59:17.877-08 Pacific/Enderbury +2022-03-04 22:59:17.877-08 Australia/LHI +2022-03-04 22:59:17.877-08 Australia/Melbourne +2022-03-04 22:59:17.877-08 Pacific/Efate +2022-03-05 00:29:17.877-08 Australia/Darwin +2022-03-05 00:59:17.877-08 Asia/Tokyo +2022-03-05 01:14:17.877-08 Australia/Eucla +2022-03-05 01:59:17.877-08 Asia/Shanghai +2022-03-05 02:59:17.877-08 Asia/Novosibirsk +2022-03-05 03:29:17.877-08 Asia/Yangon +2022-03-05 03:59:17.877-08 Asia/Omsk +2022-03-05 04:14:17.877-08 Asia/Kathmandu +2022-03-05 04:29:17.877-08 Asia/Colombo +2022-03-05 04:59:17.877-08 Asia/Oral +2022-03-05 05:29:17.877-08 Asia/Kabul +2022-03-05 05:59:17.877-08 Europe/Astrakhan +2022-03-05 06:29:17.877-08 Asia/Tehran +2022-03-05 06:59:17.877-08 Asia/Kuwait +2022-03-05 07:59:17.877-08 Asia/Nicosia +2022-03-05 08:59:17.877-08 Europe/Budapest +2022-03-05 09:59:17.877-08 Etc/GMT-0 +2022-03-05 10:59:17.877-08 Atlantic/Azores +2022-03-05 12:59:17.877-08 America/Cayenne +2022-03-05 12:59:17.877-08 America/Nuuk +2022-03-05 13:29:17.877-08 CNT +2022-03-05 13:59:17.877-08 America/Martinique +2022-03-05 14:59:17.877-08 America/Louisville +2022-03-05 15:59:17.877-08 America/Rainy_River +2022-03-05 16:59:17.877-08 America/Shiprock +2022-03-05 17:59:17.877-08 Mexico/BajaNorte +2022-03-05 18:59:17.877-08 America/Sitka +2022-03-05 19:29:17.877-08 Pacific/Marquesas +2022-03-05 19:59:17.877-08 Pacific/Johnston +2022-03-05 20:59:17.877-08 Pacific/Niue +2022-03-05 21:59:17.877-08 Etc/GMT+12 + +# Neither has TZ - should be TS not TSTZ +query II +SELECT ${func}('2022-03-05 17:59:17.877', ['%m/%d/%Y %H:%M:%S.%g', '%Y-%m-%d %H:%M:%S.%g']) tstz, tz_name +FROM zones +ORDER BY ALL +---- +2022-03-05 17:59:17.877 America/Cayenne +2022-03-05 17:59:17.877 America/Louisville +2022-03-05 17:59:17.877 America/Martinique +2022-03-05 17:59:17.877 America/Nuuk +2022-03-05 17:59:17.877 America/Rainy_River +2022-03-05 17:59:17.877 America/Shiprock +2022-03-05 17:59:17.877 America/Sitka +2022-03-05 17:59:17.877 Asia/Colombo +2022-03-05 17:59:17.877 Asia/Kabul +2022-03-05 17:59:17.877 Asia/Kathmandu +2022-03-05 17:59:17.877 Asia/Kuwait +2022-03-05 17:59:17.877 Asia/Nicosia +2022-03-05 17:59:17.877 Asia/Novosibirsk +2022-03-05 17:59:17.877 Asia/Omsk +2022-03-05 17:59:17.877 Asia/Oral +2022-03-05 17:59:17.877 Asia/Shanghai +2022-03-05 17:59:17.877 Asia/Tehran +2022-03-05 17:59:17.877 Asia/Tokyo +2022-03-05 17:59:17.877 Asia/Yangon +2022-03-05 17:59:17.877 Atlantic/Azores +2022-03-05 17:59:17.877 Australia/Darwin +2022-03-05 17:59:17.877 Australia/Eucla +2022-03-05 17:59:17.877 Australia/LHI +2022-03-05 17:59:17.877 Australia/Melbourne +2022-03-05 17:59:17.877 CNT +2022-03-05 17:59:17.877 Etc/GMT+12 +2022-03-05 17:59:17.877 Etc/GMT-0 +2022-03-05 17:59:17.877 Etc/GMT-14 +2022-03-05 17:59:17.877 Europe/Astrakhan +2022-03-05 17:59:17.877 Europe/Budapest +2022-03-05 17:59:17.877 Mexico/BajaNorte +2022-03-05 17:59:17.877 NZ-CHAT +2022-03-05 17:59:17.877 Pacific/Auckland +2022-03-05 17:59:17.877 Pacific/Efate +2022-03-05 17:59:17.877 Pacific/Enderbury +2022-03-05 17:59:17.877 Pacific/Johnston +2022-03-05 17:59:17.877 Pacific/Marquesas +2022-03-05 17:59:17.877 Pacific/Niue + endloop # diff --git a/test/sql/json/issues/issue12188.test b/test/sql/json/issues/issue12188.test new file mode 100644 index 00000000000..e1c06a2a036 --- /dev/null +++ b/test/sql/json/issues/issue12188.test @@ -0,0 +1,20 @@ +# name: test/sql/json/issues/issue12188.test +# description: Test issue 12188 - Issue with Parsing NDJSON File in DuckDB: Unexpected Quotation Marks +# group: [issues] + +require parquet + +query II +SELECT typeof(field1), typeof(field2) FROM 'data/parquet-testing/parquet_with_json.parquet' LIMIT 1 +---- +JSON JSON + +require json + +statement ok +COPY (SELECT * FROM read_ndjson('data/json/12188.ndjson', maximum_depth=1)) TO '__TEST_DIR__/my.parquet'; + +query II +SELECT typeof(field1), typeof(field2) FROM '__TEST_DIR__/my.parquet' LIMIT 1 +---- +JSON JSON diff --git a/test/sql/optimizer/expression/test_timestamp_offset.test b/test/sql/optimizer/expression/test_timestamp_offset.test new file mode 100644 index 00000000000..d2adaee0d88 --- /dev/null +++ b/test/sql/optimizer/expression/test_timestamp_offset.test @@ -0,0 +1,50 @@ +# name: test/sql/optimizer/expression/test_timestamp_offset.test +# description: Test pushdown of varchars converted to timestamps +# group: [expression] + +statement ok +PRAGMA enable_verification + +statement ok +create or replace table table1 ( + timestamp_str varchar +); + +statement ok +insert into table1 values ('2024-05-03 01:00:00'), ('2024-05-03 01:00:02'); + +query II +select timestamp_str, cast(timestamp_str as timestamp) +from table1 +where cast(timestamp_str as timestamp) > cast('2024-05-03 01:00:00' as timestamp); +---- +2024-05-03 01:00:02 2024-05-03 01:00:02 + +statement ok +truncate table table1; + +statement ok +insert into table1 values ('2024-05-03T01:00:00+00:00'), ('2024-05-03T01:00:02+00:00'); + +query II +select timestamp_str, cast(timestamp_str as timestamp) +from table1 +where cast(timestamp_str as timestamp) > cast('2024-05-03 01:00:00' as timestamp); +---- +2024-05-03T01:00:02+00:00 2024-05-03 01:00:02 + +query II +select timestamp_str, cast(timestamp_str as timestamp) +from table1 +where cast(timestamp_str as timestamp) > cast('2024-05-03T01:00:00+00:00' as timestamp); +---- +2024-05-03T01:00:02+00:00 2024-05-03 01:00:02 + +query II +select * from ( + select timestamp_str, cast(timestamp_str as timestamp) as timestamp_column + from table1 +) +where timestamp_column > cast('2024-05-03 01:00:00' as timestamp); +---- +2024-05-03T01:00:02+00:00 2024-05-03 01:00:02 diff --git a/test/sql/parallelism/interquery/concurrent_force_checkpoint.test b/test/sql/parallelism/interquery/concurrent_force_checkpoint.test index ceb88f15d8d..cf81e99f24f 100644 --- a/test/sql/parallelism/interquery/concurrent_force_checkpoint.test +++ b/test/sql/parallelism/interquery/concurrent_force_checkpoint.test @@ -40,10 +40,18 @@ endloop # thread 16-20 are reading loop i 0 100 +onlyif threadid>=16&&threadid<20 +statement ok +BEGIN TRANSACTION READ ONLY + onlyif threadid>=16&&threadid<20 statement ok SELECT COUNT(*), SUM(i) FROM integers; +onlyif threadid>=16&&threadid<20 +statement ok +COMMIT + endloop # thread 21 is force checkpointing diff --git a/test/sql/parallelism/intraquery/test_aggregations_parallelism.test_slow b/test/sql/parallelism/intraquery/test_aggregations_parallelism.test_slow index e6bc05b297f..fbd93fa6264 100644 --- a/test/sql/parallelism/intraquery/test_aggregations_parallelism.test_slow +++ b/test/sql/parallelism/intraquery/test_aggregations_parallelism.test_slow @@ -90,8 +90,8 @@ from bool; query II rowsort select approx_count_distinct(a), approx_count_distinct(b) from t group by b%2; ---- -49874 5 -51026 5 +41234 5 +50630 5 query II select arg_min(b,a), arg_max(b,a) from t; diff --git a/test/sql/parser/dollar_quotes_internal_issue2224.test b/test/sql/parser/dollar_quotes_internal_issue2224.test new file mode 100644 index 00000000000..30bf93d7eb6 --- /dev/null +++ b/test/sql/parser/dollar_quotes_internal_issue2224.test @@ -0,0 +1,81 @@ +# name: test/sql/parser/dollar_quotes_internal_issue2224.test +# description: Unexpected implicit conversion of string literal with full-width space +# group: [parser] + +# we replace unicode spaces in query strings, except if they are quoted +# internal issue 2224 found that this doesn't work properly for double-dollar quoting +# lhs is regular space, rhs is a wider unicode space, so this should be false +#query I +#select $$ $$ = $$　$$; +#---- +#false + +query I +select $tag$ $tag$ = $tag$　$tag$; +---- +false + +# worked properly before for these quotes +query I +select ' ' = '　'; +---- +false + +# just checking if parsing didn't break by fixing the dollar thing +query I +select $$$$ = ''; +---- +true + +query I +select $tag$$tag$ = ''; +---- +true + +query I +select '' = $$$$; +---- +true + +query I +select '' = $tag$$tag$; +---- +true + +query I +select $$ $$ = $$　$$ or ' ' = '　'; +---- +false + +query I +select $tag$ $tag$ = $tag$　$tag$ or ' ' = '　'; +---- +false + +query I +select ' ' = '　' or $$ $$ = $$　$$; +---- +false + +query I +select ' ' = '　' or $tag$ $tag$ = $tag$　$tag$; +---- +false + +# we can nest dollars if tags don't match +query I +select $tag$ $duck$ $tag$ = $tag$　$duck$　$tag$; +---- +false + +# of course we have to try this too +query I +select $🦆$du ck$🦆$ = $🦆$du　ck$🦆$; +---- +false + +# and some more unicode +query I +select $ü$x x$ü$ = $ü$x　x$ü$; +---- +false diff --git a/test/sql/parser/star_expression.test b/test/sql/parser/star_expression.test index c0eb9f3bb18..67088ec0bf3 100644 --- a/test/sql/parser/star_expression.test +++ b/test/sql/parser/star_expression.test @@ -64,6 +64,6 @@ VALUES (*) not supported statement error -FROM range(*, *); +FROM read_csv(*, *); ---- not supported diff --git a/test/sql/pivot/pivot_struct_aggregate.test b/test/sql/pivot/pivot_struct_aggregate.test new file mode 100644 index 00000000000..abc3d3168e4 --- /dev/null +++ b/test/sql/pivot/pivot_struct_aggregate.test @@ -0,0 +1,23 @@ +# name: test/sql/pivot/pivot_struct_aggregate.test +# description: Issue #12328: Segmentation fault during PIVOTING table (CLI) using struct field +# group: [pivot] + +statement ok +PRAGMA enable_verification + +statement ok +create table donnees_csv as select {'year': i::varchar, 'month': i::varchar} AS donnee, i%5 as variable_id, i%10 id_niv from range(1000) t(i); + +query IIIIII +pivot donnees_csv on variable_id using first(donnee) group by id_niv order by all; +---- +0 {'year': 0, 'month': 0} NULL NULL NULL NULL +1 NULL {'year': 1, 'month': 1} NULL NULL NULL +2 NULL NULL {'year': 2, 'month': 2} NULL NULL +3 NULL NULL NULL {'year': 3, 'month': 3} NULL +4 NULL NULL NULL NULL {'year': 4, 'month': 4} +5 {'year': 5, 'month': 5} NULL NULL NULL NULL +6 NULL {'year': 6, 'month': 6} NULL NULL NULL +7 NULL NULL {'year': 7, 'month': 7} NULL NULL +8 NULL NULL NULL {'year': 8, 'month': 8} NULL +9 NULL NULL NULL NULL {'year': 9, 'month': 9} diff --git a/test/sql/pragma/test_custom_profiling_settings.test b/test/sql/pragma/test_custom_profiling_settings.test index 28de3cea929..913cb25a002 100644 --- a/test/sql/pragma/test_custom_profiling_settings.test +++ b/test/sql/pragma/test_custom_profiling_settings.test @@ -24,21 +24,29 @@ statement ok SELECT cpu_time, extra_info, operator_cardinality, operator_timing FROM metrics_output; query I rowsort -SELECT unnest(string_split(current_setting('custom_profiling_settings'), ', ')); +SELECT unnest(res) from ( + select current_setting('custom_profiling_settings') as raw_setting, + raw_setting.trim('{}') as setting, + string_split(setting, ', ') as res +) ---- -CPU_TIME -EXTRA_INFO -OPERATOR_CARDINALITY -OPERATOR_TIMING +"CPU_TIME": "true" +"EXTRA_INFO": "true" +"OPERATOR_CARDINALITY": "true" +"OPERATOR_TIMING": "true" # Turn off all settings statement ok PRAGMA custom_profiling_settings='{}' query I rowsort -SELECT string_split(current_setting('custom_profiling_settings'), ', '); +SELECT unnest(res) from ( + select current_setting('custom_profiling_settings') as raw_setting, + raw_setting.trim('{}') as setting, + string_split(setting, ', ') as res +) ---- -[] +(empty) statement ok PRAGMA enable_profiling = 'json'; @@ -77,11 +85,15 @@ statement ok PRAGMA custom_profiling_settings='{"CPU_TIME": "false", "EXTRA_INFO": "true", "OPERATOR_CARDINALITY": "true", "OPERATOR_TIMING": "true"}' query I rowsort -SELECT unnest(string_split(current_setting('custom_profiling_settings'), ', ')); +SELECT unnest(res) from ( + select current_setting('custom_profiling_settings') as raw_setting, + raw_setting.trim('{}') as setting, + string_split(setting, ', ') as res +) ---- -EXTRA_INFO -OPERATOR_CARDINALITY -OPERATOR_TIMING +"EXTRA_INFO": "true" +"OPERATOR_CARDINALITY": "true" +"OPERATOR_TIMING": "true" statement ok PRAGMA enable_profiling = 'json'; @@ -108,11 +120,15 @@ statement ok PRAGMA custom_profiling_settings='{"CPU_TIME": "true", "EXTRA_INFO": "true", "OPERATOR_CARDINALITY": "true"}' query I rowsort -SELECT unnest(string_split(current_setting('custom_profiling_settings'), ', ')); +SELECT unnest(res) from ( + select current_setting('custom_profiling_settings') as raw_setting, + raw_setting.trim('{}') as setting, + string_split(setting, ', ') as res +) ---- -CPU_TIME -EXTRA_INFO -OPERATOR_CARDINALITY +"CPU_TIME": "true" +"EXTRA_INFO": "true" +"OPERATOR_CARDINALITY": "true" statement ok PRAGMA enable_profiling = 'json'; diff --git a/test/sql/storage/reclaim_space/reclaim_space_drop_column_overflow_strings.test_slow b/test/sql/storage/reclaim_space/reclaim_space_drop_column_overflow_strings.test_slow index cf6461213ff..ad43eabbe7a 100644 --- a/test/sql/storage/reclaim_space/reclaim_space_drop_column_overflow_strings.test_slow +++ b/test/sql/storage/reclaim_space/reclaim_space_drop_column_overflow_strings.test_slow @@ -21,7 +21,12 @@ SELECT AVG(STRLEN(s)), MIN(STRLEN(S)), MAX(STRLEN(S)), SUM(STRLEN(S)), MIN(S[1]) ---- 296.955 0 5000 44543527 (empty) X -loop i 0 10 +# For smaller block sizes (16KB) the total blocks alternate between a few values in the loop, +# therefore, we need to compare to a range of total block counts. +statement ok +CREATE TABLE total_blocks_tbl AS SELECT total_blocks FROM pragma_database_size(); + +loop i 0 30 statement ok ALTER TABLE strings DROP COLUMN s; @@ -40,10 +45,22 @@ SELECT AVG(STRLEN(s)), MIN(STRLEN(S)), MAX(STRLEN(S)), SUM(STRLEN(S)), MIN(S[1]) statement ok CHECKPOINT; -# ensure that the expected total storage size is the same as in the first iteration of the loop +# Ensure that the total blocks don't exceed the total blocks by more than 1.2. + +query I +SELECT CASE WHEN ${i} < 10 THEN True + WHEN current.total_blocks <= total_blocks_tbl.total_blocks * 1.2 THEN True + ELSE False END +FROM pragma_database_size() AS current, total_blocks_tbl; +---- +1 + +# Adjust total_blocks_tbl to the count after 10 warm-up iterations. -query I nosort expected_blocks -SELECT total_blocks FROM pragma_database_size(); +statement ok +UPDATE total_blocks_tbl SET total_blocks = ( + SELECT CASE WHEN ${i} < 10 THEN (SELECT current.total_blocks FROM pragma_database_size() AS current) + ELSE (total_blocks) END); restart diff --git a/test/sql/storage/reclaim_space/test_reclaim_space_alter_type.test_slow b/test/sql/storage/reclaim_space/test_reclaim_space_alter_type.test_slow index b4cebfac6cf..299c77e70c2 100644 --- a/test/sql/storage/reclaim_space/test_reclaim_space_alter_type.test_slow +++ b/test/sql/storage/reclaim_space/test_reclaim_space_alter_type.test_slow @@ -21,12 +21,12 @@ SELECT MIN(i), MAX(i), COUNT(*) FROM integers ---- 0 999999 1000000 -# for smaller block sizes (16KB) the total blocks alternate between a few values in the loop, -# therefore, we need to compare to a range of total block counts +# For smaller block sizes (16KB) the total blocks alternate between a few values in the loop, +# therefore, we need to compare to a range of total block counts. statement ok CREATE TABLE total_blocks_tbl AS SELECT total_blocks FROM pragma_database_size(); -loop i 0 10 +loop i 0 20 statement ok ALTER TABLE integers ALTER i SET DATA TYPE BIGINT; @@ -53,22 +53,21 @@ SELECT MIN(i), MAX(i), COUNT(*) FROM integers statement ok CHECKPOINT; -# ensure that the total blocks don't exceed the total blocks after the first iteration -# by more than 1.2 +# Ensure that the total blocks don't exceed the total blocks by more than 1.2. query I -SELECT CASE WHEN ${i} = 0 THEN True +SELECT CASE WHEN ${i} < 10 THEN True WHEN current.total_blocks <= total_blocks_tbl.total_blocks * 1.2 THEN True ELSE False END FROM pragma_database_size() AS current, total_blocks_tbl; ---- 1 -# adjust total_blocks_tbl once to the count after the first iteration +# Adjust total_blocks_tbl to the count after 10 warm-up iterations. statement ok UPDATE total_blocks_tbl SET total_blocks = ( - SELECT CASE WHEN ${i} = 0 THEN (SELECT current.total_blocks FROM pragma_database_size() AS current) + SELECT CASE WHEN ${i} < 10 THEN (SELECT current.total_blocks FROM pragma_database_size() AS current) ELSE (total_blocks) END); query III diff --git a/test/sql/storage/relocate_metadata.test_slow b/test/sql/storage/relocate_metadata.test_slow new file mode 100644 index 00000000000..606cf63081d --- /dev/null +++ b/test/sql/storage/relocate_metadata.test_slow @@ -0,0 +1,53 @@ +# name: test/sql/storage/relocate_metadata.test_slow +# description: Verify that metadata is relocated to allow the database to free up space +# group: [storage] + +# load the DB from disk +load __TEST_DIR__/relocate_metadata.db + +statement ok +CREATE TABLE test (x INT, y AS (x + 100)); + +statement ok +insert into test select range FROM range(100000000); + +statement ok +delete from test where x % 10 = 7; + +statement ok +delete from test where x % 10 = 6; + +statement ok +delete from test where x % 10 = 5; + +statement ok +delete from test where x % 10 = 4; + +statement ok +delete from test where x % 10 = 3; + +statement ok +delete from test where x % 10 = 2; + +statement ok +delete from test where x % 10 = 1; + +statement ok +delete from test where x % 10 = 0; + +statement ok +delete from test where x % 10 = 8; + +statement ok +delete from test where x % 10 = 9; + +statement ok +drop table test; + +statement ok +checkpoint + +query I +SELECT MAX(block_id)<5 FROM pragma_metadata_info(); +---- +true diff --git a/test/sql/subquery/lateral/test_lateral_join.test b/test/sql/subquery/lateral/test_lateral_join.test index 91237b50440..1c1f2b556ff 100644 --- a/test/sql/subquery/lateral/test_lateral_join.test +++ b/test/sql/subquery/lateral/test_lateral_join.test @@ -13,6 +13,18 @@ select (select MIN(val) from unnest((select a)) t(val)) from (select ARRAY[1, 2, ---- 1 +query I +select (select MIN(val) from unnest((select (select a))) t(val)) from (select ARRAY[1, 2, 3, NULL]) t(a); +---- +1 + +query II +select * from (select array[1, 2, 3] a), unnest((select (select (select a)))) +---- +[1, 2, 3] 1 +[1, 2, 3] 2 +[1, 2, 3] 3 + query I select (select MIN(val) from unnest(a) t(val)) from (select ARRAY[1, 2, 3, NULL]) t(a); ---- diff --git a/test/sql/table_function/range_function_lateral.test b/test/sql/table_function/range_function_lateral.test new file mode 100644 index 00000000000..63e53186049 --- /dev/null +++ b/test/sql/table_function/range_function_lateral.test @@ -0,0 +1,134 @@ +# name: test/sql/table_function/range_function_lateral.test +# description: Test range functions with lateral functions +# group: [table_function] + +statement ok +PRAGMA enable_verification + +query I +SELECT * FROM range(1, NULL, 1); +---- + +query II +SELECT * FROM (SELECT NULL a), range(a); +---- + +query II +SELECT * FROM (SELECT NULL a), range(timestamp '2010-01-01', a, null); +---- + +query II +SELECT * FROM range(3) t(i), range(i) t2(j) ORDER BY i, j; +---- +1 0 +2 0 +2 1 + +query III +SELECT * FROM range(4) t(i), range(i) t2(j), range(j) t3(k) ORDER BY i, j, k; +---- +2 1 0 +3 1 0 +3 2 0 +3 2 1 + +query III +SELECT * FROM generate_series(0,2) t(i), generate_series(0,i) t2(j), generate_series(0,j) t3(k) ORDER BY i, j, k; +---- +0 0 0 +1 0 0 +1 1 0 +1 1 1 +2 0 0 +2 1 0 +2 1 1 +2 2 0 +2 2 1 +2 2 2 + +query IIII +SELECT i, j, l, str FROM (SELECT ARRAY['null'], NULL, 'null' UNION ALL SELECT ARRAY['five'], 5, 'five' UNION ALL SELECT ARRAY['two'], 2, 'two') t(l, i, str), generate_series(0,i-1) t2(j) order by i, j +---- +2 0 [two] two +2 1 [two] two +5 0 [five] five +5 1 [five] five +5 2 [five] five +5 3 [five] five +5 4 [five] five + +query II +SELECT * FROM (SELECT 42 WHERE 42>84) t(i), range(i) t2(j) +---- + +statement error +SELECT * FROM (SELECT '5'::VARCHAR) t(str), range(str) t2(j) +---- +No function matches the given name and argument types + +statement ok +PREPARE v1 AS SELECT * FROM range(?); + +query I +EXECUTE v1(5) +---- +0 +1 +2 +3 +4 + +query IIII +SELECT * FROM (SELECT 3, 1, -1 UNION ALL SELECT 1, 3, 2) t(s, e, increment), range(s, e, increment) t2(j) ORDER BY s, j +---- +1 3 2 1 +3 1 -1 2 +3 1 -1 3 + +query IIII +SELECT * FROM (SELECT DATE '2000-01-01', DATE '2000-10-1', INTERVAL '3' MONTHS) t(s, e, increment), range(s, e, increment) t2(j) ORDER BY s, j +---- +2000-01-01 2000-10-01 3 months 2000-01-01 00:00:00 +2000-01-01 2000-10-01 3 months 2000-04-01 00:00:00 +2000-01-01 2000-10-01 3 months 2000-07-01 00:00:00 + +query IIII +SELECT * FROM (SELECT DATE '2000-01-01', DATE '2000-10-1', INTERVAL '3' MONTHS) t(s, e, increment), generate_series(s, e, increment) t2(j) ORDER BY s, j +---- +2000-01-01 2000-10-01 3 months 2000-01-01 00:00:00 +2000-01-01 2000-10-01 3 months 2000-04-01 00:00:00 +2000-01-01 2000-10-01 3 months 2000-07-01 00:00:00 +2000-01-01 2000-10-01 3 months 2000-10-01 00:00:00 + +query IIII +SELECT * FROM (SELECT DATE '2000-01-01', DATE '2000-10-1', NULL) t(s, e, increment), generate_series(s, e, increment) t2(j) ORDER BY s, j +---- + +# many rows +query I +select count(*) from (values (1), (10), (100), (1000), (10000)) t(a), range(a); +---- +11111 + +require icu + +statement ok +SET TimeZone='UTC' + +query IIII +SELECT * FROM (SELECT TIMESTAMPTZ '2000-01-01', TIMESTAMPTZ '2000-10-1', INTERVAL '3' MONTHS) t(s, e, increment), range(s, e, increment) t2(j) ORDER BY s, j +---- +2000-01-01 00:00:00+00 2000-10-01 00:00:00+00 3 months 2000-01-01 00:00:00+00 +2000-01-01 00:00:00+00 2000-10-01 00:00:00+00 3 months 2000-04-01 00:00:00+00 +2000-01-01 00:00:00+00 2000-10-01 00:00:00+00 3 months 2000-07-01 00:00:00+00 + +query IIII +SELECT * FROM (SELECT TIMESTAMPTZ '2000-01-01', TIMESTAMPTZ '2000-10-1', NULL) t(s, e, increment), range(s, e, increment) t2(j) ORDER BY s, j +---- + +query IIII +SELECT * FROM (SELECT TIMESTAMPTZ '2000-01-01', TIMESTAMPTZ '2000-10-1', NULL UNION ALL SELECT TIMESTAMPTZ '2000-10-01', TIMESTAMPTZ '2000-01-1', INTERVAL '-3 months') t(s, e, increment), range(s, e, increment) t2(j) ORDER BY s, j +---- +2000-10-01 00:00:00+00 2000-01-01 00:00:00+00 -3 months 2000-04-01 00:00:00+00 +2000-10-01 00:00:00+00 2000-01-01 00:00:00+00 -3 months 2000-07-01 00:00:00+00 +2000-10-01 00:00:00+00 2000-01-01 00:00:00+00 -3 months 2000-10-01 00:00:00+00 diff --git a/test/sql/table_function/range_timestamp.test b/test/sql/table_function/range_timestamp.test index 5bdcfb19bf0..103b97e7aee 100644 --- a/test/sql/table_function/range_timestamp.test +++ b/test/sql/table_function/range_timestamp.test @@ -115,6 +115,17 @@ SELECT COUNT(*) FROM generate_series(TIMESTAMP '1992-01-01 00:00:00', TIMESTAMP ---- 10228 +# null values result in no rows +query I +SELECT COUNT(*) FROM range(NULL, TIMESTAMP '1992-12-31 12:00:00', INTERVAL '1 MONTH') tbl(d) +---- +0 + +query I +SELECT COUNT(*) FROM generate_series(NULL, TIMESTAMP '1992-12-31 12:00:00', INTERVAL '1 MONTH') tbl(d) +---- +0 + # zero interval not supported statement error SELECT d FROM range(TIMESTAMP '1992-01-01 00:00:00', TIMESTAMP '1992-12-31 12:00:00', INTERVAL '0 MONTH') tbl(d) diff --git a/test/sql/transactions/test_read_only_transactions.test b/test/sql/transactions/test_read_only_transactions.test new file mode 100644 index 00000000000..46b6943ebb1 --- /dev/null +++ b/test/sql/transactions/test_read_only_transactions.test @@ -0,0 +1,30 @@ +# name: test/sql/transactions/test_read_only_transactions.test +# description: Test read only transactions +# group: [transactions] + +statement ok +PRAGMA enable_verification + +statement ok +CREATE TABLE a(i INTEGER) + +statement ok +INSERT INTO a VALUES (42) + +statement ok +BEGIN TRANSACTION READ ONLY + +# we can read from the database +query I +SELECT * FROM a +---- +42 + +# we cannot modify the database in a read-only transaction +statement error +INSERT INTO a VALUES (48) +---- +transaction is launched in read-only mode + +statement ok +COMMIT diff --git a/test/sql/types/date/date_implicit_cast.test b/test/sql/types/date/date_implicit_cast.test new file mode 100644 index 00000000000..eda2bb362b0 --- /dev/null +++ b/test/sql/types/date/date_implicit_cast.test @@ -0,0 +1,25 @@ +# name: test/sql/types/date/date_implicit_cast.test +# description: Test date implicit casts +# group: [date] + +statement ok +PRAGMA enable_verification + +foreach type timestamp timestamp_ms timestamp_ns timestamp_s + +statement ok +CREATE TABLE timestamps(ts ${type}) + +statement ok +INSERT INTO timestamps VALUES ('1993-08-14 00:00:00'), ('1993-08-15 01:01:02'), ('1993-08-16 00:00:00') + +query I +SELECT * FROM timestamps WHERE ts >= date '1993-08-15' +---- +1993-08-15 01:01:02 +1993-08-16 00:00:00 + +statement ok +DROP TABLE timestamps + +endloop diff --git a/test/sql/types/list/unnest_table_function.test b/test/sql/types/list/unnest_table_function.test index 322783df97f..5b33cdc3203 100644 --- a/test/sql/types/list/unnest_table_function.test +++ b/test/sql/types/list/unnest_table_function.test @@ -70,29 +70,28 @@ SELECT i FROM UNNEST([]::INT[]) AS tbl(i); ---- # unnest from a subquery +# postgres returns an error here query I -SELECT * FROM UNNEST((SELECT [1,2,3] UNION ALL SELECT [4,5])); +SELECT * FROM UNNEST((SELECT ARRAY[1,2,3] UNION ALL SELECT ARRAY[1,2,3])); ---- 1 2 3 -4 -5 statement ok CREATE TABLE lists AS SELECT [1,2,3] l UNION ALL SELECT [4,5] UNION ALL SELECT [] UNION ALL SELECT [NULL] UNION ALL SELECT [7, 8]; query I -SELECT * FROM UNNEST((SELECT l FROM lists)); +SELECT u FROM lists, UNNEST(l) AS unnest(u) ORDER BY l, u; ---- 1 2 3 4 5 -NULL 7 8 +NULL # unnest with a prepared statement parameter statement ok @@ -156,3 +155,33 @@ SELECT k, a, b, a [4, 5, 5] [5, 7] [5] b [2, 3] [1, 2, 3, 4] [2, 3] c [2, 3] [4] [] + + +# aliases +query I +SELECT unnest FROM UNNEST(ARRAY[1,2,3]); +---- +1 +2 +3 + +query I +SELECT a FROM UNNEST(ARRAY[1,2,3]) t(a); +---- +1 +2 +3 + +query I +SELECT unnest FROM (SELECT ARRAY[1,2,3] AS x), UNNEST(x); +---- +1 +2 +3 + +query I +SELECT b FROM (SELECT ARRAY[1,2,3] AS x), UNNEST(x) t(b); +---- +1 +2 +3 diff --git a/test/sql/upsert/postgres/composite_key.test b/test/sql/upsert/postgres/composite_key.test index 054c8077e69..fdf5db0780e 100644 --- a/test/sql/upsert/postgres/composite_key.test +++ b/test/sql/upsert/postgres/composite_key.test @@ -37,7 +37,7 @@ statement error insert into insertconflicttest values (0, 'Crowberry', 0) on conflict (key, fruit) do update set other = 1 where exists (select 1 from insertconflicttest ii where ii.key = excluded.key); ---- -Binder Error: conflict_target WHERE clause can not be a subquery +DO UPDATE SET clause cannot contain a subquery # inference succeeds: diff --git a/test/sql/upsert/upsert_lambda.test b/test/sql/upsert/upsert_lambda.test new file mode 100644 index 00000000000..74f5fb7fd31 --- /dev/null +++ b/test/sql/upsert/upsert_lambda.test @@ -0,0 +1,91 @@ +# name: test/sql/upsert/upsert_lambda.test +# group: [upsert] + +statement ok +PRAGMA enable_verification; + +statement ok +CREATE OR REPLACE TABLE foo ( + pk_col INT PRIMARY KEY, + str VARCHAR, + str_list VARCHAR[], + payload_col INT +); + +statement ok +INSERT INTO foo +SELECT 1, 'hello', ['x', 'y', 'z'], 40 +ON CONFLICT DO UPDATE SET + str = list_reduce(EXCLUDED.str_list, (x, y) -> x || '||' || y); + +query IIII +FROM foo; +---- +1 hello [x, y, z] 40 + +# Use the new (excluded) list as input. + +statement ok +INSERT INTO foo +SELECT 1, 'world', ['a', 'b', 'c'], 41 +ON CONFLICT DO UPDATE SET + str = list_reduce(EXCLUDED.str_list, (x, y) -> x || '||' || y); + +query IIII +FROM foo; +---- +1 a||b||c [x, y, z] 40 + +# Additionally update the payload. + +statement ok +INSERT INTO foo +SELECT 1, '', ['1', '2'], 42 +ON CONFLICT DO UPDATE SET + str = list_reduce(EXCLUDED.str_list, (x, y) -> x || '||' || y), + payload_col = EXCLUDED.payload_col; + +query IIII +FROM foo; +---- +1 1||2 [x, y, z] 42 + +# Use the existing list as input. + +statement ok +INSERT INTO foo +SELECT 1, '', ['l', 'm', 'n'], 43 +ON CONFLICT DO UPDATE SET + str = list_reduce(str_list, (x, y) -> x || '||' || y); + +query IIII +FROM foo; +---- +1 x||y||z [x, y, z] 42 + +# Reference the existing and the new (excluded) str column without qualification. + +statement ok +INSERT INTO foo +SELECT 1, 'world', ['s', 't'], 42 +ON CONFLICT DO UPDATE SET + str = list_reduce(EXCLUDED.str_list, (x, y) -> x || str || y || EXCLUDED.str); + +query IIII +FROM foo; +---- +1 sx||y||ztworld [x, y, z] 42 + +# Lambda function in the WHERE clause. + +statement ok +INSERT INTO foo +SELECT 1, 'motorcycle', ['brrr', 'brrrrrr'], 1042 +ON CONFLICT DO UPDATE SET + str = 'black-bellied whistling duck' + WHERE list_reduce(EXCLUDED.str_list, (x, y) -> x || str || y || EXCLUDED.str) = 'brrrsx||y||ztworldbrrrrrrmotorcycle'; + +query IIII +FROM foo; +---- +1 black-bellied whistling duck [x, y, z] 42 diff --git a/test/sql/vacuum/vacuum_nested_types.test b/test/sql/vacuum/vacuum_nested_types.test index ff1e1706858..5c862798385 100644 --- a/test/sql/vacuum/vacuum_nested_types.test +++ b/test/sql/vacuum/vacuum_nested_types.test @@ -3,10 +3,10 @@ # group: [vacuum] statement ok -CREATE TABLE test (x INT[], y AS (x || 100)); +CREATE TABLE test (x INT[], y AS (x || [100])); statement ok ANALYZE test(y, x); statement ok -INSERT INTO test SELECT [range % 5000] FROM range(10000); \ No newline at end of file +INSERT INTO test SELECT [range % 5000] FROM range(10000); diff --git a/test/sql/window/test_streaming_window.test b/test/sql/window/test_streaming_window.test index 8518b75979b..9aa79fe122b 100644 --- a/test/sql/window/test_streaming_window.test +++ b/test/sql/window/test_streaming_window.test @@ -50,23 +50,6 @@ SELECT j, SUM(j) FILTER(WHERE i = 2) OVER(ROWS BETWEEN UNBOUNDED PRECEDING AND C ---- physical_plan :.*STREAMING_WINDOW.* -# DISTINCT is not supported for streaming windows -query TT -EXPLAIN -SELECT - LIST(DISTINCT col0) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS result -FROM (VALUES ({'key': 'A'}), ({'key': 'B'}), ({'key': 'A'})) ----- -physical_plan :.*STREAMING_WINDOW.* - -query TT -EXPLAIN -SELECT - LIST(DISTINCT col0) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS result -FROM (VALUES ({'key': 'A'}), ({'key': 'B'}), ({'key': 'A'})) ----- -physical_plan :.*STREAMING_WINDOW.* - # Test each of the streaming window functions query TT explain select row_number() over (), i, j from integers diff --git a/test/sql/window/test_streaming_window_distinct.test b/test/sql/window/test_streaming_window_distinct.test new file mode 100644 index 00000000000..27f02cf7242 --- /dev/null +++ b/test/sql/window/test_streaming_window_distinct.test @@ -0,0 +1,87 @@ +# name: test/sql/window/test_streaming_window_distinct.test +# description: Test streaming window support for DISTINCT (+FILTER) +# group: [window] + +statement ok +PRAGMA enable_verification + +statement ok +PRAGMA explain_output = PHYSICAL_ONLY; + +# DISTINCT only +query TT +explain +SELECT i, + SUM(DISTINCT i % 3) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) +FROM range(10) tbl(i) +---- +physical_plan :.*STREAMING_WINDOW.* + +query II +SELECT i, + SUM(DISTINCT i % 3) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) +FROM range(10) tbl(i) +---- +0 0 +1 1 +2 3 +3 3 +4 3 +5 3 +6 3 +7 3 +8 3 +9 3 + +# DISTINCT LISTs +query TT +EXPLAIN +SELECT + LIST(DISTINCT col0) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS result +FROM (VALUES ({'key': 'A'}), ({'key': 'B'}), ({'key': 'A'})) +---- +physical_plan :.*STREAMING_WINDOW.* + +query I +SELECT + LIST(DISTINCT col0) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS result +FROM (VALUES ({'key': 'A'}), ({'key': 'B'}), ({'key': 'A'})) +---- +[{'key': A}] +[{'key': A}, {'key': B}] +[{'key': A}, {'key': B}] + +# DISTINCT + FILTER +query TT +explain +SELECT i, + SUM(DISTINCT i % 5) FILTER (i % 3 = 0) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) +FROM range(20) tbl(i) +---- +physical_plan :.*STREAMING_WINDOW.* + +query II +SELECT i, + SUM(DISTINCT i % 5) FILTER (i % 3 = 0) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) +FROM range(20) tbl(i) +---- +0 0 +1 0 +2 0 +3 3 +4 3 +5 3 +6 4 +7 4 +8 4 +9 8 +10 8 +11 8 +12 10 +13 10 +14 10 +15 10 +16 10 +17 10 +18 10 +19 10 diff --git a/test/sqlite/result_helper.cpp b/test/sqlite/result_helper.cpp index 573a7908002..2911c3d06b7 100644 --- a/test/sqlite/result_helper.cpp +++ b/test/sqlite/result_helper.cpp @@ -1,12 +1,13 @@ #include "result_helper.hpp" -#include "re2/re2.h" + #include "catch.hpp" -#include "termcolor.hpp" -#include "sqllogic_test_runner.hpp" #include "duckdb/common/crypto/md5.hpp" #include "duckdb/parser/qualified_name.hpp" -#include "test_helpers.hpp" +#include "re2/re2.h" #include "sqllogic_test_logger.hpp" +#include "sqllogic_test_runner.hpp" +#include "termcolor.hpp" +#include "test_helpers.hpp" #include @@ -279,8 +280,19 @@ bool TestResultHelper::CheckStatementResult(const Statement &statement, ExecuteC } if (result.HasError() && !statement.expected_error.empty()) { if (!StringUtil::Contains(result.GetError(), statement.expected_error)) { - logger.ExpectedErrorMismatch(statement.expected_error, result); - return false; + bool success = false; + if (StringUtil::StartsWith(statement.expected_error, ":") || + StringUtil::StartsWith(statement.expected_error, ":")) { + success = MatchesRegex(logger, result, statement.expected_error); + } + if (!success) { + logger.ExpectedErrorMismatch(statement.expected_error, result); + return false; + } + string success_log = + StringUtil::Format("CheckStatementResult: %s:%d", statement.file_name, statement.query_line); + REQUIRE(success_log.c_str()); + return true; } } } @@ -438,21 +450,7 @@ bool TestResultHelper::CompareValues(SQLLogicTestLogger &logger, MaterializedQue return true; } if (StringUtil::StartsWith(rvalue_str, ":") || StringUtil::StartsWith(rvalue_str, ":")) { - bool want_match = StringUtil::StartsWith(rvalue_str, ":"); - string regex_str = StringUtil::Replace(StringUtil::Replace(rvalue_str, ":", ""), ":", ""); - RE2::Options options; - options.set_dot_nl(true); - RE2 re(regex_str, options); - if (!re.ok()) { - logger.PrintErrorHeader("Test error!"); - logger.PrintLineSep(); - std::cerr << termcolor::red << termcolor::bold << "Failed to parse regex: " << re.error() - << termcolor::reset << std::endl; - logger.PrintLineSep(); - return false; - } - bool regex_matches = RE2::FullMatch(lvalue_str, re); - if (regex_matches == want_match) { + if (MatchesRegex(logger, result, rvalue_str)) { return true; } } @@ -523,4 +521,27 @@ bool TestResultHelper::CompareValues(SQLLogicTestLogger &logger, MaterializedQue return true; } +bool TestResultHelper::MatchesRegex(SQLLogicTestLogger &logger, MaterializedQueryResult &result, string rvalue_str) { + bool want_match = StringUtil::StartsWith(rvalue_str, ":"); + string regex_str = StringUtil::Replace(StringUtil::Replace(rvalue_str, ":", ""), ":", ""); + + RE2::Options options; + options.set_dot_nl(true); + RE2 re(regex_str, options); + if (!re.ok()) { + logger.PrintErrorHeader("Test error!"); + logger.PrintLineSep(); + std::cerr << termcolor::red << termcolor::bold << "Failed to parse regex: " << re.error() << termcolor::reset + << std::endl; + logger.PrintLineSep(); + return false; + } + auto resString = result.ToString(); + bool regex_matches = RE2::FullMatch(result.ToString(), re); + if ((want_match && regex_matches) || (!want_match && !regex_matches)) { + return true; + } + return false; +} + } // namespace duckdb diff --git a/test/sqlite/result_helper.hpp b/test/sqlite/result_helper.hpp index b074da7bd66..f313e9b0c08 100644 --- a/test/sqlite/result_helper.hpp +++ b/test/sqlite/result_helper.hpp @@ -27,13 +27,13 @@ class TestResultHelper { duckdb::unique_ptr owned_result); bool CheckStatementResult(const Statement &statement, ExecuteContext &context, duckdb::unique_ptr owned_result); - string SQLLogicTestConvertValue(Value value, LogicalType sql_type, bool original_sqlite_test); void DuckDBConvertResult(MaterializedQueryResult &result, bool original_sqlite_test, vector &out_result); static bool ResultIsHash(const string &result); static bool ResultIsFile(string result); + bool MatchesRegex(SQLLogicTestLogger &logger, MaterializedQueryResult &result, string rvalue_str); bool CompareValues(SQLLogicTestLogger &logger, MaterializedQueryResult &result, string lvalue_str, string rvalue_str, idx_t current_row, idx_t current_column, vector &values, idx_t expected_column_count, bool row_wise, vector &result_values); diff --git a/test/sqlite/select4.test_slow b/test/sqlite/select4.test_slow index 25a41e513ba..39d2fa34739 100644 --- a/test/sqlite/select4.test_slow +++ b/test/sqlite/select4.test_slow @@ -48300,4 +48300,3 @@ SELECT c6*856, x5 AND c5 in (820,44,696,824,668,723,598) ---- 28 values hashing to 8ceb8232c1e6c7b7f5d87ea5c54e08d0 - diff --git a/test/sqlsmith/sql_reduce.test b/test/sqlsmith/sql_reduce.test deleted file mode 100644 index 432fc8581bb..00000000000 --- a/test/sqlsmith/sql_reduce.test +++ /dev/null @@ -1,79 +0,0 @@ -# name: test/sqlsmith/sql_reduce.test -# description: Test reduce SQL statement -# group: [sqlsmith] - -require sqlsmith - -query I -SELECT * FROM reduce_sql_statement('SELECT a, b FROM tbl') ORDER BY 1 ----- -SELECT NULL, b FROM tbl -SELECT NULL, b FROM tbl -SELECT a FROM tbl -SELECT a, NULL FROM tbl -SELECT a, NULL FROM tbl -SELECT a, b -SELECT a, b FROM tbl -SELECT a, b FROM tbl -SELECT b FROM tbl - -query I -SELECT * FROM reduce_sql_statement('SELECT a, b FROM tbl WHERE a AND b') ORDER BY 1 ----- -SELECT NULL, b FROM tbl WHERE (a AND b) -SELECT NULL, b FROM tbl WHERE (a AND b) -SELECT a FROM tbl WHERE (a AND b) -SELECT a, NULL FROM tbl WHERE (a AND b) -SELECT a, NULL FROM tbl WHERE (a AND b) -SELECT a, b FROM tbl -SELECT a, b FROM tbl WHERE (NULL AND b) -SELECT a, b FROM tbl WHERE (NULL AND b) -SELECT a, b FROM tbl WHERE (a AND NULL) -SELECT a, b FROM tbl WHERE (a AND NULL) -SELECT a, b FROM tbl WHERE (a AND b) -SELECT a, b FROM tbl WHERE (a AND b) -SELECT a, b FROM tbl WHERE NULL -SELECT a, b FROM tbl WHERE NULL -SELECT a, b FROM tbl WHERE a -SELECT a, b FROM tbl WHERE a -SELECT a, b FROM tbl WHERE b -SELECT a, b FROM tbl WHERE b -SELECT a, b WHERE (a AND b) -SELECT b FROM tbl WHERE (a AND b) - -query I -SELECT * FROM reduce_sql_statement('INSERT INTO tbl VALUES (1, 2)') ORDER BY 1 ----- -INSERT INTO tbl (VALUES (1)) -INSERT INTO tbl (VALUES (1, 2)) -INSERT INTO tbl (VALUES (2)) -INSERT INTO tbl SELECT * -INSERT INTO tbl SELECT NULL FROM (VALUES (1, 2)) -INSERT INTO tbl SELECT NULL FROM (VALUES (1, 2)) AS valueslist - -query I -SELECT * FROM reduce_sql_statement('UPDATE tbl SET i=3, j=4 WHERE z=5') ORDER BY 1 ----- -UPDATE tbl SET i = 3 WHERE (z = 5) -UPDATE tbl SET i = 3, j = 4 -UPDATE tbl SET i = 3, j = 4 WHERE (NULL = 5) -UPDATE tbl SET i = 3, j = 4 WHERE 5 -UPDATE tbl SET i = 3, j = 4 WHERE NULL -UPDATE tbl SET i = 3, j = 4 WHERE z -UPDATE tbl SET j = 4 WHERE (z = 5) - -query I -SELECT * FROM reduce_sql_statement('DELETE FROM a WHERE i >= 2000 AND i < 5000;') ORDER BY 1 ----- -DELETE FROM a -DELETE FROM a WHERE ((NULL >= 2000) AND (i < 5000)) -DELETE FROM a WHERE ((i >= 2000) AND (NULL < 5000)) -DELETE FROM a WHERE ((i >= 2000) AND 5000) -DELETE FROM a WHERE ((i >= 2000) AND NULL) -DELETE FROM a WHERE ((i >= 2000) AND i) -DELETE FROM a WHERE (2000 AND (i < 5000)) -DELETE FROM a WHERE (NULL AND (i < 5000)) -DELETE FROM a WHERE (i < 5000) -DELETE FROM a WHERE (i >= 2000) -DELETE FROM a WHERE (i AND (i < 5000)) -DELETE FROM a WHERE NULL diff --git a/third_party/hyperloglog/hyperloglog.hpp b/third_party/hyperloglog/hyperloglog.hpp index 461ecc53a56..68e3159f810 100644 --- a/third_party/hyperloglog/hyperloglog.hpp +++ b/third_party/hyperloglog/hyperloglog.hpp @@ -40,6 +40,10 @@ robj *hll_merge(robj **hlls, size_t hll_count); //! Get size (in bytes) of the HLL uint64_t get_size(); +//! Helper Functions +double hllSigma(double x); +double hllTau(double x); + uint64_t MurmurHash64A(const void *key, int len, unsigned int seed); // NOLINTEND diff --git a/third_party/libpg_query/grammar/grammar.y b/third_party/libpg_query/grammar/grammar.y index a850e56d946..e9ab7b4feb7 100644 --- a/third_party/libpg_query/grammar/grammar.y +++ b/third_party/libpg_query/grammar/grammar.y @@ -59,6 +59,7 @@ PGViewCheckOption viewcheckoption; PGInsertColumnOrder bynameorposition; PGLoadInstallType loadinstalltype; + PGTransactionStmtType transactiontype; } %type stmt diff --git a/third_party/libpg_query/grammar/statements/transaction.y b/third_party/libpg_query/grammar/statements/transaction.y index ac443fe9e77..b9ebdf90a16 100644 --- a/third_party/libpg_query/grammar/statements/transaction.y +++ b/third_party/libpg_query/grammar/statements/transaction.y @@ -4,18 +4,21 @@ TransactionStmt: PGTransactionStmt *n = makeNode(PGTransactionStmt); n->kind = PG_TRANS_STMT_ROLLBACK; n->options = NIL; + n->transaction_type = PG_TRANS_TYPE_DEFAULT; $$ = (PGNode *)n; } - | BEGIN_P opt_transaction + | BEGIN_P opt_transaction opt_transaction_type { PGTransactionStmt *n = makeNode(PGTransactionStmt); n->kind = PG_TRANS_STMT_BEGIN; + n->transaction_type = $3; $$ = (PGNode *)n; } - | START opt_transaction + | START opt_transaction opt_transaction_type { PGTransactionStmt *n = makeNode(PGTransactionStmt); n->kind = PG_TRANS_STMT_START; + n->transaction_type = $3; $$ = (PGNode *)n; } | COMMIT opt_transaction @@ -23,6 +26,7 @@ TransactionStmt: PGTransactionStmt *n = makeNode(PGTransactionStmt); n->kind = PG_TRANS_STMT_COMMIT; n->options = NIL; + n->transaction_type = PG_TRANS_TYPE_DEFAULT; $$ = (PGNode *)n; } | END_P opt_transaction @@ -30,6 +34,7 @@ TransactionStmt: PGTransactionStmt *n = makeNode(PGTransactionStmt); n->kind = PG_TRANS_STMT_COMMIT; n->options = NIL; + n->transaction_type = PG_TRANS_TYPE_DEFAULT; $$ = (PGNode *)n; } | ROLLBACK opt_transaction @@ -37,6 +42,7 @@ TransactionStmt: PGTransactionStmt *n = makeNode(PGTransactionStmt); n->kind = PG_TRANS_STMT_ROLLBACK; n->options = NIL; + n->transaction_type = PG_TRANS_TYPE_DEFAULT; $$ = (PGNode *)n; } ; @@ -46,3 +52,9 @@ opt_transaction: WORK {} | TRANSACTION {} | /*EMPTY*/ {} ; + +opt_transaction_type: + READ_P ONLY { $$ = PG_TRANS_TYPE_READ_ONLY; } + | READ_P WRITE_P { $$ = PG_TRANS_TYPE_READ_WRITE; } + | /*EMPTY*/ { $$ = PG_TRANS_TYPE_DEFAULT; } + ; diff --git a/third_party/libpg_query/grammar/types/transaction.yh b/third_party/libpg_query/grammar/types/transaction.yh new file mode 100644 index 00000000000..fe829c5bc09 --- /dev/null +++ b/third_party/libpg_query/grammar/types/transaction.yh @@ -0,0 +1 @@ +%type opt_transaction_type diff --git a/third_party/libpg_query/include/nodes/parsenodes.hpp b/third_party/libpg_query/include/nodes/parsenodes.hpp index 46472415e93..4097420099a 100755 --- a/third_party/libpg_query/include/nodes/parsenodes.hpp +++ b/third_party/libpg_query/include/nodes/parsenodes.hpp @@ -1857,11 +1857,18 @@ typedef enum PGTransactionStmtKind { TRANS_STMT_ROLLBACK_PREPARED } PGTransactionStmtKind; +typedef enum PGTransactionStmtType { + PG_TRANS_TYPE_DEFAULT, + PG_TRANS_TYPE_READ_ONLY, // explicit READ ONLY + PG_TRANS_TYPE_READ_WRITE // explicit READ WRITE +} PGTransactionStmtType; + typedef struct PGTransactionStmt { PGNodeTag type; - PGTransactionStmtKind kind; /* see above */ - PGList *options; /* for BEGIN/START and savepoint commands */ - char *gid; /* for two-phase-commit related commands */ + PGTransactionStmtKind kind; /* see above */ + PGList *options; /* for BEGIN/START and savepoint commands */ + char *gid; /* for two-phase-commit related commands */ + PGTransactionStmtType transaction_type; /* read only or read write */ } PGTransactionStmt; /* ---------------------- diff --git a/third_party/libpg_query/include/parser/gram.hpp b/third_party/libpg_query/include/parser/gram.hpp index ff5116796c6..393431c4aba 100644 --- a/third_party/libpg_query/include/parser/gram.hpp +++ b/third_party/libpg_query/include/parser/gram.hpp @@ -1,14 +1,14 @@ -/* 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 @@ -16,7 +16,9 @@ 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 @@ -31,542 +33,1029 @@ 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 */ - EXTENSIONS = 412, /* EXTENSIONS */ - EXTERNAL = 413, /* EXTERNAL */ - EXTRACT = 414, /* EXTRACT */ - FALSE_P = 415, /* FALSE_P */ - FAMILY = 416, /* FAMILY */ - FETCH = 417, /* FETCH */ - FILTER = 418, /* FILTER */ - FIRST_P = 419, /* FIRST_P */ - FLOAT_P = 420, /* FLOAT_P */ - FOLLOWING = 421, /* FOLLOWING */ - FOR = 422, /* FOR */ - FORCE = 423, /* FORCE */ - FOREIGN = 424, /* FOREIGN */ - FORWARD = 425, /* FORWARD */ - FREEZE = 426, /* FREEZE */ - FROM = 427, /* FROM */ - FULL = 428, /* FULL */ - FUNCTION = 429, /* FUNCTION */ - FUNCTIONS = 430, /* FUNCTIONS */ - GENERATED = 431, /* GENERATED */ - GLOB = 432, /* GLOB */ - GLOBAL = 433, /* GLOBAL */ - GRANT = 434, /* GRANT */ - GRANTED = 435, /* GRANTED */ - GROUP_P = 436, /* GROUP_P */ - GROUPING = 437, /* GROUPING */ - GROUPING_ID = 438, /* GROUPING_ID */ - GROUPS = 439, /* GROUPS */ - HANDLER = 440, /* HANDLER */ - HAVING = 441, /* HAVING */ - HEADER_P = 442, /* HEADER_P */ - HOLD = 443, /* HOLD */ - HOUR_P = 444, /* HOUR_P */ - HOURS_P = 445, /* HOURS_P */ - IDENTITY_P = 446, /* IDENTITY_P */ - IF_P = 447, /* IF_P */ - IGNORE_P = 448, /* IGNORE_P */ - ILIKE = 449, /* ILIKE */ - IMMEDIATE = 450, /* IMMEDIATE */ - IMMUTABLE = 451, /* IMMUTABLE */ - IMPLICIT_P = 452, /* IMPLICIT_P */ - IMPORT_P = 453, /* IMPORT_P */ - IN_P = 454, /* IN_P */ - INCLUDE_P = 455, /* INCLUDE_P */ - INCLUDING = 456, /* INCLUDING */ - INCREMENT = 457, /* INCREMENT */ - INDEX = 458, /* INDEX */ - INDEXES = 459, /* INDEXES */ - INHERIT = 460, /* INHERIT */ - INHERITS = 461, /* INHERITS */ - INITIALLY = 462, /* INITIALLY */ - INLINE_P = 463, /* INLINE_P */ - INNER_P = 464, /* INNER_P */ - INOUT = 465, /* INOUT */ - INPUT_P = 466, /* INPUT_P */ - INSENSITIVE = 467, /* INSENSITIVE */ - INSERT = 468, /* INSERT */ - INSTALL = 469, /* INSTALL */ - INSTEAD = 470, /* INSTEAD */ - INT_P = 471, /* INT_P */ - INTEGER = 472, /* INTEGER */ - INTERSECT = 473, /* INTERSECT */ - INTERVAL = 474, /* INTERVAL */ - INTO = 475, /* INTO */ - INVOKER = 476, /* INVOKER */ - IS = 477, /* IS */ - ISNULL = 478, /* ISNULL */ - ISOLATION = 479, /* ISOLATION */ - JOIN = 480, /* JOIN */ - JSON = 481, /* JSON */ - KEY = 482, /* KEY */ - LABEL = 483, /* LABEL */ - LANGUAGE = 484, /* LANGUAGE */ - LARGE_P = 485, /* LARGE_P */ - LAST_P = 486, /* LAST_P */ - LATERAL_P = 487, /* LATERAL_P */ - LEADING = 488, /* LEADING */ - LEAKPROOF = 489, /* LEAKPROOF */ - LEFT = 490, /* LEFT */ - LEVEL = 491, /* LEVEL */ - LIKE = 492, /* LIKE */ - LIMIT = 493, /* LIMIT */ - LISTEN = 494, /* LISTEN */ - LOAD = 495, /* LOAD */ - LOCAL = 496, /* LOCAL */ - LOCATION = 497, /* LOCATION */ - LOCK_P = 498, /* LOCK_P */ - LOCKED = 499, /* LOCKED */ - LOGGED = 500, /* LOGGED */ - MACRO = 501, /* MACRO */ - MAP = 502, /* MAP */ - MAPPING = 503, /* MAPPING */ - MATCH = 504, /* MATCH */ - MATERIALIZED = 505, /* MATERIALIZED */ - MAXVALUE = 506, /* MAXVALUE */ - METHOD = 507, /* METHOD */ - MICROSECOND_P = 508, /* MICROSECOND_P */ - MICROSECONDS_P = 509, /* MICROSECONDS_P */ - MILLENNIA_P = 510, /* MILLENNIA_P */ - MILLENNIUM_P = 511, /* MILLENNIUM_P */ - MILLISECOND_P = 512, /* MILLISECOND_P */ - MILLISECONDS_P = 513, /* MILLISECONDS_P */ - MINUTE_P = 514, /* MINUTE_P */ - MINUTES_P = 515, /* MINUTES_P */ - MINVALUE = 516, /* MINVALUE */ - MODE = 517, /* MODE */ - MONTH_P = 518, /* MONTH_P */ - MONTHS_P = 519, /* MONTHS_P */ - MOVE = 520, /* MOVE */ - NAME_P = 521, /* NAME_P */ - NAMES = 522, /* NAMES */ - NATIONAL = 523, /* NATIONAL */ - NATURAL = 524, /* NATURAL */ - NCHAR = 525, /* NCHAR */ - NEW = 526, /* NEW */ - NEXT = 527, /* NEXT */ - NO = 528, /* NO */ - NONE = 529, /* NONE */ - NOT = 530, /* NOT */ - NOTHING = 531, /* NOTHING */ - NOTIFY = 532, /* NOTIFY */ - NOTNULL = 533, /* NOTNULL */ - NOWAIT = 534, /* NOWAIT */ - NULL_P = 535, /* NULL_P */ - NULLIF = 536, /* NULLIF */ - NULLS_P = 537, /* NULLS_P */ - NUMERIC = 538, /* NUMERIC */ - OBJECT_P = 539, /* OBJECT_P */ - OF = 540, /* OF */ - OFF = 541, /* OFF */ - OFFSET = 542, /* OFFSET */ - OIDS = 543, /* OIDS */ - OLD = 544, /* OLD */ - ON = 545, /* ON */ - ONLY = 546, /* ONLY */ - OPERATOR = 547, /* OPERATOR */ - OPTION = 548, /* OPTION */ - OPTIONS = 549, /* OPTIONS */ - OR = 550, /* OR */ - ORDER = 551, /* ORDER */ - ORDINALITY = 552, /* ORDINALITY */ - OTHERS = 553, /* OTHERS */ - OUT_P = 554, /* OUT_P */ - OUTER_P = 555, /* OUTER_P */ - OVER = 556, /* OVER */ - OVERLAPS = 557, /* OVERLAPS */ - OVERLAY = 558, /* OVERLAY */ - OVERRIDING = 559, /* OVERRIDING */ - OWNED = 560, /* OWNED */ - OWNER = 561, /* OWNER */ - PARALLEL = 562, /* PARALLEL */ - PARSER = 563, /* PARSER */ - PARTIAL = 564, /* PARTIAL */ - PARTITION = 565, /* PARTITION */ - PASSING = 566, /* PASSING */ - PASSWORD = 567, /* PASSWORD */ - PERCENT = 568, /* PERCENT */ - PERSISTENT = 569, /* PERSISTENT */ - PIVOT = 570, /* PIVOT */ - PIVOT_LONGER = 571, /* PIVOT_LONGER */ - PIVOT_WIDER = 572, /* PIVOT_WIDER */ - PLACING = 573, /* PLACING */ - PLANS = 574, /* PLANS */ - POLICY = 575, /* POLICY */ - POSITION = 576, /* POSITION */ - POSITIONAL = 577, /* POSITIONAL */ - PRAGMA_P = 578, /* PRAGMA_P */ - PRECEDING = 579, /* PRECEDING */ - PRECISION = 580, /* PRECISION */ - PREPARE = 581, /* PREPARE */ - PREPARED = 582, /* PREPARED */ - PRESERVE = 583, /* PRESERVE */ - PRIMARY = 584, /* PRIMARY */ - PRIOR = 585, /* PRIOR */ - PRIVILEGES = 586, /* PRIVILEGES */ - PROCEDURAL = 587, /* PROCEDURAL */ - PROCEDURE = 588, /* PROCEDURE */ - PROGRAM = 589, /* PROGRAM */ - PUBLICATION = 590, /* PUBLICATION */ - QUALIFY = 591, /* QUALIFY */ - QUARTER_P = 592, /* QUARTER_P */ - QUARTERS_P = 593, /* QUARTERS_P */ - QUOTE = 594, /* QUOTE */ - RANGE = 595, /* RANGE */ - READ_P = 596, /* READ_P */ - REAL = 597, /* REAL */ - REASSIGN = 598, /* REASSIGN */ - RECHECK = 599, /* RECHECK */ - RECURSIVE = 600, /* RECURSIVE */ - REF = 601, /* REF */ - REFERENCES = 602, /* REFERENCES */ - REFERENCING = 603, /* REFERENCING */ - REFRESH = 604, /* REFRESH */ - REINDEX = 605, /* REINDEX */ - RELATIVE_P = 606, /* RELATIVE_P */ - RELEASE = 607, /* RELEASE */ - RENAME = 608, /* RENAME */ - REPEATABLE = 609, /* REPEATABLE */ - REPLACE = 610, /* REPLACE */ - REPLICA = 611, /* REPLICA */ - RESET = 612, /* RESET */ - RESPECT_P = 613, /* RESPECT_P */ - RESTART = 614, /* RESTART */ - RESTRICT = 615, /* RESTRICT */ - RETURNING = 616, /* RETURNING */ - RETURNS = 617, /* RETURNS */ - REVOKE = 618, /* REVOKE */ - RIGHT = 619, /* RIGHT */ - ROLE = 620, /* ROLE */ - ROLLBACK = 621, /* ROLLBACK */ - ROLLUP = 622, /* ROLLUP */ - ROW = 623, /* ROW */ - ROWS = 624, /* ROWS */ - RULE = 625, /* RULE */ - SAMPLE = 626, /* SAMPLE */ - SAVEPOINT = 627, /* SAVEPOINT */ - SCHEMA = 628, /* SCHEMA */ - SCHEMAS = 629, /* SCHEMAS */ - SCOPE = 630, /* SCOPE */ - SCROLL = 631, /* SCROLL */ - SEARCH = 632, /* SEARCH */ - SECOND_P = 633, /* SECOND_P */ - SECONDS_P = 634, /* SECONDS_P */ - SECRET = 635, /* SECRET */ - SECURITY = 636, /* SECURITY */ - SELECT = 637, /* SELECT */ - SEMI = 638, /* SEMI */ - SEQUENCE = 639, /* SEQUENCE */ - SEQUENCES = 640, /* SEQUENCES */ - SERIALIZABLE = 641, /* SERIALIZABLE */ - SERVER = 642, /* SERVER */ - SESSION = 643, /* SESSION */ - SET = 644, /* SET */ - SETOF = 645, /* SETOF */ - SETS = 646, /* SETS */ - SHARE = 647, /* SHARE */ - SHOW = 648, /* SHOW */ - SIMILAR = 649, /* SIMILAR */ - SIMPLE = 650, /* SIMPLE */ - SKIP = 651, /* SKIP */ - SMALLINT = 652, /* SMALLINT */ - SNAPSHOT = 653, /* SNAPSHOT */ - SOME = 654, /* SOME */ - SQL_P = 655, /* SQL_P */ - STABLE = 656, /* STABLE */ - STANDALONE_P = 657, /* STANDALONE_P */ - START = 658, /* START */ - STATEMENT = 659, /* STATEMENT */ - STATISTICS = 660, /* STATISTICS */ - STDIN = 661, /* STDIN */ - STDOUT = 662, /* STDOUT */ - STORAGE = 663, /* STORAGE */ - STORED = 664, /* STORED */ - STRICT_P = 665, /* STRICT_P */ - STRIP_P = 666, /* STRIP_P */ - STRUCT = 667, /* STRUCT */ - SUBSCRIPTION = 668, /* SUBSCRIPTION */ - SUBSTRING = 669, /* SUBSTRING */ - SUMMARIZE = 670, /* SUMMARIZE */ - SYMMETRIC = 671, /* SYMMETRIC */ - SYSID = 672, /* SYSID */ - SYSTEM_P = 673, /* SYSTEM_P */ - TABLE = 674, /* TABLE */ - TABLES = 675, /* TABLES */ - TABLESAMPLE = 676, /* TABLESAMPLE */ - TABLESPACE = 677, /* TABLESPACE */ - TEMP = 678, /* TEMP */ - TEMPLATE = 679, /* TEMPLATE */ - TEMPORARY = 680, /* TEMPORARY */ - TEXT_P = 681, /* TEXT_P */ - THEN = 682, /* THEN */ - TIES = 683, /* TIES */ - TIME = 684, /* TIME */ - TIMESTAMP = 685, /* TIMESTAMP */ - TO = 686, /* TO */ - TRAILING = 687, /* TRAILING */ - TRANSACTION = 688, /* TRANSACTION */ - TRANSFORM = 689, /* TRANSFORM */ - TREAT = 690, /* TREAT */ - TRIGGER = 691, /* TRIGGER */ - TRIM = 692, /* TRIM */ - TRUE_P = 693, /* TRUE_P */ - TRUNCATE = 694, /* TRUNCATE */ - TRUSTED = 695, /* TRUSTED */ - TRY_CAST = 696, /* TRY_CAST */ - TYPE_P = 697, /* TYPE_P */ - TYPES_P = 698, /* TYPES_P */ - UNBOUNDED = 699, /* UNBOUNDED */ - UNCOMMITTED = 700, /* UNCOMMITTED */ - UNENCRYPTED = 701, /* UNENCRYPTED */ - UNION = 702, /* UNION */ - UNIQUE = 703, /* UNIQUE */ - UNKNOWN = 704, /* UNKNOWN */ - UNLISTEN = 705, /* UNLISTEN */ - UNLOGGED = 706, /* UNLOGGED */ - UNPIVOT = 707, /* UNPIVOT */ - UNTIL = 708, /* UNTIL */ - UPDATE = 709, /* UPDATE */ - USE_P = 710, /* USE_P */ - USER = 711, /* USER */ - USING = 712, /* USING */ - VACUUM = 713, /* VACUUM */ - VALID = 714, /* VALID */ - VALIDATE = 715, /* VALIDATE */ - VALIDATOR = 716, /* VALIDATOR */ - VALUE_P = 717, /* VALUE_P */ - VALUES = 718, /* VALUES */ - VARCHAR = 719, /* VARCHAR */ - VARIADIC = 720, /* VARIADIC */ - VARYING = 721, /* VARYING */ - VERBOSE = 722, /* VERBOSE */ - VERSION_P = 723, /* VERSION_P */ - VIEW = 724, /* VIEW */ - VIEWS = 725, /* VIEWS */ - VIRTUAL = 726, /* VIRTUAL */ - VOLATILE = 727, /* VOLATILE */ - WEEK_P = 728, /* WEEK_P */ - WEEKS_P = 729, /* WEEKS_P */ - WHEN = 730, /* WHEN */ - WHERE = 731, /* WHERE */ - WHITESPACE_P = 732, /* WHITESPACE_P */ - WINDOW = 733, /* WINDOW */ - WITH = 734, /* WITH */ - WITHIN = 735, /* WITHIN */ - WITHOUT = 736, /* WITHOUT */ - WORK = 737, /* WORK */ - WRAPPER = 738, /* WRAPPER */ - WRITE_P = 739, /* WRITE_P */ - XML_P = 740, /* XML_P */ - XMLATTRIBUTES = 741, /* XMLATTRIBUTES */ - XMLCONCAT = 742, /* XMLCONCAT */ - XMLELEMENT = 743, /* XMLELEMENT */ - XMLEXISTS = 744, /* XMLEXISTS */ - XMLFOREST = 745, /* XMLFOREST */ - XMLNAMESPACES = 746, /* XMLNAMESPACES */ - XMLPARSE = 747, /* XMLPARSE */ - XMLPI = 748, /* XMLPI */ - XMLROOT = 749, /* XMLROOT */ - XMLSERIALIZE = 750, /* XMLSERIALIZE */ - XMLTABLE = 751, /* XMLTABLE */ - YEAR_P = 752, /* YEAR_P */ - YEARS_P = 753, /* YEARS_P */ - YES_P = 754, /* YES_P */ - ZONE = 755, /* ZONE */ - NOT_LA = 756, /* NOT_LA */ - NULLS_LA = 757, /* NULLS_LA */ - WITH_LA = 758, /* WITH_LA */ - POSTFIXOP = 759, /* POSTFIXOP */ - UMINUS = 760 /* 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, + EXTENSIONS = 412, + EXTERNAL = 413, + EXTRACT = 414, + FALSE_P = 415, + FAMILY = 416, + FETCH = 417, + FILTER = 418, + FIRST_P = 419, + FLOAT_P = 420, + FOLLOWING = 421, + FOR = 422, + FORCE = 423, + FOREIGN = 424, + FORWARD = 425, + FREEZE = 426, + FROM = 427, + FULL = 428, + FUNCTION = 429, + FUNCTIONS = 430, + GENERATED = 431, + GLOB = 432, + GLOBAL = 433, + GRANT = 434, + GRANTED = 435, + GROUP_P = 436, + GROUPING = 437, + GROUPING_ID = 438, + GROUPS = 439, + HANDLER = 440, + HAVING = 441, + HEADER_P = 442, + HOLD = 443, + HOUR_P = 444, + HOURS_P = 445, + IDENTITY_P = 446, + IF_P = 447, + IGNORE_P = 448, + ILIKE = 449, + IMMEDIATE = 450, + IMMUTABLE = 451, + IMPLICIT_P = 452, + IMPORT_P = 453, + IN_P = 454, + INCLUDE_P = 455, + INCLUDING = 456, + INCREMENT = 457, + INDEX = 458, + INDEXES = 459, + INHERIT = 460, + INHERITS = 461, + INITIALLY = 462, + INLINE_P = 463, + INNER_P = 464, + INOUT = 465, + INPUT_P = 466, + INSENSITIVE = 467, + INSERT = 468, + INSTALL = 469, + INSTEAD = 470, + INT_P = 471, + INTEGER = 472, + INTERSECT = 473, + INTERVAL = 474, + INTO = 475, + INVOKER = 476, + IS = 477, + ISNULL = 478, + ISOLATION = 479, + JOIN = 480, + JSON = 481, + KEY = 482, + LABEL = 483, + LANGUAGE = 484, + LARGE_P = 485, + LAST_P = 486, + LATERAL_P = 487, + LEADING = 488, + LEAKPROOF = 489, + LEFT = 490, + LEVEL = 491, + LIKE = 492, + LIMIT = 493, + LISTEN = 494, + LOAD = 495, + LOCAL = 496, + LOCATION = 497, + LOCK_P = 498, + LOCKED = 499, + LOGGED = 500, + MACRO = 501, + MAP = 502, + MAPPING = 503, + MATCH = 504, + MATERIALIZED = 505, + MAXVALUE = 506, + METHOD = 507, + MICROSECOND_P = 508, + MICROSECONDS_P = 509, + MILLENNIA_P = 510, + MILLENNIUM_P = 511, + MILLISECOND_P = 512, + MILLISECONDS_P = 513, + MINUTE_P = 514, + MINUTES_P = 515, + MINVALUE = 516, + MODE = 517, + MONTH_P = 518, + MONTHS_P = 519, + MOVE = 520, + NAME_P = 521, + NAMES = 522, + NATIONAL = 523, + NATURAL = 524, + NCHAR = 525, + NEW = 526, + NEXT = 527, + NO = 528, + NONE = 529, + NOT = 530, + NOTHING = 531, + NOTIFY = 532, + NOTNULL = 533, + NOWAIT = 534, + NULL_P = 535, + NULLIF = 536, + NULLS_P = 537, + NUMERIC = 538, + OBJECT_P = 539, + OF = 540, + OFF = 541, + OFFSET = 542, + OIDS = 543, + OLD = 544, + ON = 545, + ONLY = 546, + OPERATOR = 547, + OPTION = 548, + OPTIONS = 549, + OR = 550, + ORDER = 551, + ORDINALITY = 552, + OTHERS = 553, + OUT_P = 554, + OUTER_P = 555, + OVER = 556, + OVERLAPS = 557, + OVERLAY = 558, + OVERRIDING = 559, + OWNED = 560, + OWNER = 561, + PARALLEL = 562, + PARSER = 563, + PARTIAL = 564, + PARTITION = 565, + PASSING = 566, + PASSWORD = 567, + PERCENT = 568, + PERSISTENT = 569, + PIVOT = 570, + PIVOT_LONGER = 571, + PIVOT_WIDER = 572, + PLACING = 573, + PLANS = 574, + POLICY = 575, + POSITION = 576, + POSITIONAL = 577, + PRAGMA_P = 578, + PRECEDING = 579, + PRECISION = 580, + PREPARE = 581, + PREPARED = 582, + PRESERVE = 583, + PRIMARY = 584, + PRIOR = 585, + PRIVILEGES = 586, + PROCEDURAL = 587, + PROCEDURE = 588, + PROGRAM = 589, + PUBLICATION = 590, + QUALIFY = 591, + QUARTER_P = 592, + QUARTERS_P = 593, + QUOTE = 594, + RANGE = 595, + READ_P = 596, + REAL = 597, + REASSIGN = 598, + RECHECK = 599, + RECURSIVE = 600, + REF = 601, + REFERENCES = 602, + REFERENCING = 603, + REFRESH = 604, + REINDEX = 605, + RELATIVE_P = 606, + RELEASE = 607, + RENAME = 608, + REPEATABLE = 609, + REPLACE = 610, + REPLICA = 611, + RESET = 612, + RESPECT_P = 613, + RESTART = 614, + RESTRICT = 615, + RETURNING = 616, + RETURNS = 617, + REVOKE = 618, + RIGHT = 619, + ROLE = 620, + ROLLBACK = 621, + ROLLUP = 622, + ROW = 623, + ROWS = 624, + RULE = 625, + SAMPLE = 626, + SAVEPOINT = 627, + SCHEMA = 628, + SCHEMAS = 629, + SCOPE = 630, + SCROLL = 631, + SEARCH = 632, + SECOND_P = 633, + SECONDS_P = 634, + SECRET = 635, + SECURITY = 636, + SELECT = 637, + SEMI = 638, + SEQUENCE = 639, + SEQUENCES = 640, + SERIALIZABLE = 641, + SERVER = 642, + SESSION = 643, + SET = 644, + SETOF = 645, + SETS = 646, + SHARE = 647, + SHOW = 648, + SIMILAR = 649, + SIMPLE = 650, + SKIP = 651, + SMALLINT = 652, + SNAPSHOT = 653, + SOME = 654, + SQL_P = 655, + STABLE = 656, + STANDALONE_P = 657, + START = 658, + STATEMENT = 659, + STATISTICS = 660, + STDIN = 661, + STDOUT = 662, + STORAGE = 663, + STORED = 664, + STRICT_P = 665, + STRIP_P = 666, + STRUCT = 667, + SUBSCRIPTION = 668, + SUBSTRING = 669, + SUMMARIZE = 670, + SYMMETRIC = 671, + SYSID = 672, + SYSTEM_P = 673, + TABLE = 674, + TABLES = 675, + TABLESAMPLE = 676, + TABLESPACE = 677, + TEMP = 678, + TEMPLATE = 679, + TEMPORARY = 680, + TEXT_P = 681, + THEN = 682, + TIES = 683, + TIME = 684, + TIMESTAMP = 685, + TO = 686, + TRAILING = 687, + TRANSACTION = 688, + TRANSFORM = 689, + TREAT = 690, + TRIGGER = 691, + TRIM = 692, + TRUE_P = 693, + TRUNCATE = 694, + TRUSTED = 695, + TRY_CAST = 696, + TYPE_P = 697, + TYPES_P = 698, + UNBOUNDED = 699, + UNCOMMITTED = 700, + UNENCRYPTED = 701, + UNION = 702, + UNIQUE = 703, + UNKNOWN = 704, + UNLISTEN = 705, + UNLOGGED = 706, + UNPIVOT = 707, + UNTIL = 708, + UPDATE = 709, + USE_P = 710, + USER = 711, + USING = 712, + VACUUM = 713, + VALID = 714, + VALIDATE = 715, + VALIDATOR = 716, + VALUE_P = 717, + VALUES = 718, + VARCHAR = 719, + VARIADIC = 720, + VARYING = 721, + VERBOSE = 722, + VERSION_P = 723, + VIEW = 724, + VIEWS = 725, + VIRTUAL = 726, + VOLATILE = 727, + WEEK_P = 728, + WEEKS_P = 729, + WHEN = 730, + WHERE = 731, + WHITESPACE_P = 732, + WINDOW = 733, + WITH = 734, + WITHIN = 735, + WITHOUT = 736, + WORK = 737, + WRAPPER = 738, + WRITE_P = 739, + XML_P = 740, + XMLATTRIBUTES = 741, + XMLCONCAT = 742, + XMLELEMENT = 743, + XMLEXISTS = 744, + XMLFOREST = 745, + XMLNAMESPACES = 746, + XMLPARSE = 747, + XMLPI = 748, + XMLROOT = 749, + XMLSERIALIZE = 750, + XMLTABLE = 751, + YEAR_P = 752, + YEARS_P = 753, + YES_P = 754, + ZONE = 755, + NOT_LA = 756, + NULLS_LA = 757, + WITH_LA = 758, + POSTFIXOP = 759, + UMINUS = 760 + }; #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 EXTENSIONS 412 +#define EXTERNAL 413 +#define EXTRACT 414 +#define FALSE_P 415 +#define FAMILY 416 +#define FETCH 417 +#define FILTER 418 +#define FIRST_P 419 +#define FLOAT_P 420 +#define FOLLOWING 421 +#define FOR 422 +#define FORCE 423 +#define FOREIGN 424 +#define FORWARD 425 +#define FREEZE 426 +#define FROM 427 +#define FULL 428 +#define FUNCTION 429 +#define FUNCTIONS 430 +#define GENERATED 431 +#define GLOB 432 +#define GLOBAL 433 +#define GRANT 434 +#define GRANTED 435 +#define GROUP_P 436 +#define GROUPING 437 +#define GROUPING_ID 438 +#define GROUPS 439 +#define HANDLER 440 +#define HAVING 441 +#define HEADER_P 442 +#define HOLD 443 +#define HOUR_P 444 +#define HOURS_P 445 +#define IDENTITY_P 446 +#define IF_P 447 +#define IGNORE_P 448 +#define ILIKE 449 +#define IMMEDIATE 450 +#define IMMUTABLE 451 +#define IMPLICIT_P 452 +#define IMPORT_P 453 +#define IN_P 454 +#define INCLUDE_P 455 +#define INCLUDING 456 +#define INCREMENT 457 +#define INDEX 458 +#define INDEXES 459 +#define INHERIT 460 +#define INHERITS 461 +#define INITIALLY 462 +#define INLINE_P 463 +#define INNER_P 464 +#define INOUT 465 +#define INPUT_P 466 +#define INSENSITIVE 467 +#define INSERT 468 +#define INSTALL 469 +#define INSTEAD 470 +#define INT_P 471 +#define INTEGER 472 +#define INTERSECT 473 +#define INTERVAL 474 +#define INTO 475 +#define INVOKER 476 +#define IS 477 +#define ISNULL 478 +#define ISOLATION 479 +#define JOIN 480 +#define JSON 481 +#define KEY 482 +#define LABEL 483 +#define LANGUAGE 484 +#define LARGE_P 485 +#define LAST_P 486 +#define LATERAL_P 487 +#define LEADING 488 +#define LEAKPROOF 489 +#define LEFT 490 +#define LEVEL 491 +#define LIKE 492 +#define LIMIT 493 +#define LISTEN 494 +#define LOAD 495 +#define LOCAL 496 +#define LOCATION 497 +#define LOCK_P 498 +#define LOCKED 499 +#define LOGGED 500 +#define MACRO 501 +#define MAP 502 +#define MAPPING 503 +#define MATCH 504 +#define MATERIALIZED 505 +#define MAXVALUE 506 +#define METHOD 507 +#define MICROSECOND_P 508 +#define MICROSECONDS_P 509 +#define MILLENNIA_P 510 +#define MILLENNIUM_P 511 +#define MILLISECOND_P 512 +#define MILLISECONDS_P 513 +#define MINUTE_P 514 +#define MINUTES_P 515 +#define MINVALUE 516 +#define MODE 517 +#define MONTH_P 518 +#define MONTHS_P 519 +#define MOVE 520 +#define NAME_P 521 +#define NAMES 522 +#define NATIONAL 523 +#define NATURAL 524 +#define NCHAR 525 +#define NEW 526 +#define NEXT 527 +#define NO 528 +#define NONE 529 +#define NOT 530 +#define NOTHING 531 +#define NOTIFY 532 +#define NOTNULL 533 +#define NOWAIT 534 +#define NULL_P 535 +#define NULLIF 536 +#define NULLS_P 537 +#define NUMERIC 538 +#define OBJECT_P 539 +#define OF 540 +#define OFF 541 +#define OFFSET 542 +#define OIDS 543 +#define OLD 544 +#define ON 545 +#define ONLY 546 +#define OPERATOR 547 +#define OPTION 548 +#define OPTIONS 549 +#define OR 550 +#define ORDER 551 +#define ORDINALITY 552 +#define OTHERS 553 +#define OUT_P 554 +#define OUTER_P 555 +#define OVER 556 +#define OVERLAPS 557 +#define OVERLAY 558 +#define OVERRIDING 559 +#define OWNED 560 +#define OWNER 561 +#define PARALLEL 562 +#define PARSER 563 +#define PARTIAL 564 +#define PARTITION 565 +#define PASSING 566 +#define PASSWORD 567 +#define PERCENT 568 +#define PERSISTENT 569 +#define PIVOT 570 +#define PIVOT_LONGER 571 +#define PIVOT_WIDER 572 +#define PLACING 573 +#define PLANS 574 +#define POLICY 575 +#define POSITION 576 +#define POSITIONAL 577 +#define PRAGMA_P 578 +#define PRECEDING 579 +#define PRECISION 580 +#define PREPARE 581 +#define PREPARED 582 +#define PRESERVE 583 +#define PRIMARY 584 +#define PRIOR 585 +#define PRIVILEGES 586 +#define PROCEDURAL 587 +#define PROCEDURE 588 +#define PROGRAM 589 +#define PUBLICATION 590 +#define QUALIFY 591 +#define QUARTER_P 592 +#define QUARTERS_P 593 +#define QUOTE 594 +#define RANGE 595 +#define READ_P 596 +#define REAL 597 +#define REASSIGN 598 +#define RECHECK 599 +#define RECURSIVE 600 +#define REF 601 +#define REFERENCES 602 +#define REFERENCING 603 +#define REFRESH 604 +#define REINDEX 605 +#define RELATIVE_P 606 +#define RELEASE 607 +#define RENAME 608 +#define REPEATABLE 609 +#define REPLACE 610 +#define REPLICA 611 +#define RESET 612 +#define RESPECT_P 613 +#define RESTART 614 +#define RESTRICT 615 +#define RETURNING 616 +#define RETURNS 617 +#define REVOKE 618 +#define RIGHT 619 +#define ROLE 620 +#define ROLLBACK 621 +#define ROLLUP 622 +#define ROW 623 +#define ROWS 624 +#define RULE 625 +#define SAMPLE 626 +#define SAVEPOINT 627 +#define SCHEMA 628 +#define SCHEMAS 629 +#define SCOPE 630 +#define SCROLL 631 +#define SEARCH 632 +#define SECOND_P 633 +#define SECONDS_P 634 +#define SECRET 635 +#define SECURITY 636 +#define SELECT 637 +#define SEMI 638 +#define SEQUENCE 639 +#define SEQUENCES 640 +#define SERIALIZABLE 641 +#define SERVER 642 +#define SESSION 643 +#define SET 644 +#define SETOF 645 +#define SETS 646 +#define SHARE 647 +#define SHOW 648 +#define SIMILAR 649 +#define SIMPLE 650 +#define SKIP 651 +#define SMALLINT 652 +#define SNAPSHOT 653 +#define SOME 654 +#define SQL_P 655 +#define STABLE 656 +#define STANDALONE_P 657 +#define START 658 +#define STATEMENT 659 +#define STATISTICS 660 +#define STDIN 661 +#define STDOUT 662 +#define STORAGE 663 +#define STORED 664 +#define STRICT_P 665 +#define STRIP_P 666 +#define STRUCT 667 +#define SUBSCRIPTION 668 +#define SUBSTRING 669 +#define SUMMARIZE 670 +#define SYMMETRIC 671 +#define SYSID 672 +#define SYSTEM_P 673 +#define TABLE 674 +#define TABLES 675 +#define TABLESAMPLE 676 +#define TABLESPACE 677 +#define TEMP 678 +#define TEMPLATE 679 +#define TEMPORARY 680 +#define TEXT_P 681 +#define THEN 682 +#define TIES 683 +#define TIME 684 +#define TIMESTAMP 685 +#define TO 686 +#define TRAILING 687 +#define TRANSACTION 688 +#define TRANSFORM 689 +#define TREAT 690 +#define TRIGGER 691 +#define TRIM 692 +#define TRUE_P 693 +#define TRUNCATE 694 +#define TRUSTED 695 +#define TRY_CAST 696 +#define TYPE_P 697 +#define TYPES_P 698 +#define UNBOUNDED 699 +#define UNCOMMITTED 700 +#define UNENCRYPTED 701 +#define UNION 702 +#define UNIQUE 703 +#define UNKNOWN 704 +#define UNLISTEN 705 +#define UNLOGGED 706 +#define UNPIVOT 707 +#define UNTIL 708 +#define UPDATE 709 +#define USE_P 710 +#define USER 711 +#define USING 712 +#define VACUUM 713 +#define VALID 714 +#define VALIDATE 715 +#define VALIDATOR 716 +#define VALUE_P 717 +#define VALUES 718 +#define VARCHAR 719 +#define VARIADIC 720 +#define VARYING 721 +#define VERBOSE 722 +#define VERSION_P 723 +#define VIEW 724 +#define VIEWS 725 +#define VIRTUAL 726 +#define VOLATILE 727 +#define WEEK_P 728 +#define WEEKS_P 729 +#define WHEN 730 +#define WHERE 731 +#define WHITESPACE_P 732 +#define WINDOW 733 +#define WITH 734 +#define WITHIN 735 +#define WITHOUT 736 +#define WORK 737 +#define WRAPPER 738 +#define WRITE_P 739 +#define XML_P 740 +#define XMLATTRIBUTES 741 +#define XMLCONCAT 742 +#define XMLELEMENT 743 +#define XMLEXISTS 744 +#define XMLFOREST 745 +#define XMLNAMESPACES 746 +#define XMLPARSE 747 +#define XMLPI 748 +#define XMLROOT 749 +#define XMLSERIALIZE 750 +#define XMLTABLE 751 +#define YEAR_P 752 +#define YEARS_P 753 +#define YES_P 754 +#define ZONE 755 +#define NOT_LA 756 +#define NULLS_LA 757 +#define WITH_LA 758 +#define POSTFIXOP 759 +#define UMINUS 760 + + + -/* 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; @@ -614,33 +1103,29 @@ union YYSTYPE PGViewCheckOption viewcheckoption; PGInsertColumnOrder bynameorposition; PGLoadInstallType loadinstalltype; - -#line 619 "third_party/libpg_query/grammar/grammar_out.hpp" - -}; -typedef union YYSTYPE YYSTYPE; -# define YYSTYPE_IS_TRIVIAL 1 + PGTransactionStmtType transactiontype; +} +/* Line 1529 of yacc.c. */ +#line 1110 "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 - - -int base_yyparse (core_yyscan_t yyscanner); - - -#endif /* !YY_BASE_YY_THIRD_PARTY_LIBPG_QUERY_GRAMMAR_GRAMMAR_OUT_HPP_INCLUDED */ diff --git a/third_party/libpg_query/src_backend_parser_gram.cpp b/third_party/libpg_query/src_backend_parser_gram.cpp index b3189b24aeb..5a34431564d 100644 --- a/third_party/libpg_query/src_backend_parser_gram.cpp +++ b/third_party/libpg_query/src_backend_parser_gram.cpp @@ -1,14 +1,14 @@ -/* 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 @@ -16,7 +16,9 @@ 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 @@ -34,10 +36,6 @@ /* 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. @@ -45,11 +43,11 @@ 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" @@ -57,21 +55,1039 @@ /* 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, + EXTENSIONS = 412, + EXTERNAL = 413, + EXTRACT = 414, + FALSE_P = 415, + FAMILY = 416, + FETCH = 417, + FILTER = 418, + FIRST_P = 419, + FLOAT_P = 420, + FOLLOWING = 421, + FOR = 422, + FORCE = 423, + FOREIGN = 424, + FORWARD = 425, + FREEZE = 426, + FROM = 427, + FULL = 428, + FUNCTION = 429, + FUNCTIONS = 430, + GENERATED = 431, + GLOB = 432, + GLOBAL = 433, + GRANT = 434, + GRANTED = 435, + GROUP_P = 436, + GROUPING = 437, + GROUPING_ID = 438, + GROUPS = 439, + HANDLER = 440, + HAVING = 441, + HEADER_P = 442, + HOLD = 443, + HOUR_P = 444, + HOURS_P = 445, + IDENTITY_P = 446, + IF_P = 447, + IGNORE_P = 448, + ILIKE = 449, + IMMEDIATE = 450, + IMMUTABLE = 451, + IMPLICIT_P = 452, + IMPORT_P = 453, + IN_P = 454, + INCLUDE_P = 455, + INCLUDING = 456, + INCREMENT = 457, + INDEX = 458, + INDEXES = 459, + INHERIT = 460, + INHERITS = 461, + INITIALLY = 462, + INLINE_P = 463, + INNER_P = 464, + INOUT = 465, + INPUT_P = 466, + INSENSITIVE = 467, + INSERT = 468, + INSTALL = 469, + INSTEAD = 470, + INT_P = 471, + INTEGER = 472, + INTERSECT = 473, + INTERVAL = 474, + INTO = 475, + INVOKER = 476, + IS = 477, + ISNULL = 478, + ISOLATION = 479, + JOIN = 480, + JSON = 481, + KEY = 482, + LABEL = 483, + LANGUAGE = 484, + LARGE_P = 485, + LAST_P = 486, + LATERAL_P = 487, + LEADING = 488, + LEAKPROOF = 489, + LEFT = 490, + LEVEL = 491, + LIKE = 492, + LIMIT = 493, + LISTEN = 494, + LOAD = 495, + LOCAL = 496, + LOCATION = 497, + LOCK_P = 498, + LOCKED = 499, + LOGGED = 500, + MACRO = 501, + MAP = 502, + MAPPING = 503, + MATCH = 504, + MATERIALIZED = 505, + MAXVALUE = 506, + METHOD = 507, + MICROSECOND_P = 508, + MICROSECONDS_P = 509, + MILLENNIA_P = 510, + MILLENNIUM_P = 511, + MILLISECOND_P = 512, + MILLISECONDS_P = 513, + MINUTE_P = 514, + MINUTES_P = 515, + MINVALUE = 516, + MODE = 517, + MONTH_P = 518, + MONTHS_P = 519, + MOVE = 520, + NAME_P = 521, + NAMES = 522, + NATIONAL = 523, + NATURAL = 524, + NCHAR = 525, + NEW = 526, + NEXT = 527, + NO = 528, + NONE = 529, + NOT = 530, + NOTHING = 531, + NOTIFY = 532, + NOTNULL = 533, + NOWAIT = 534, + NULL_P = 535, + NULLIF = 536, + NULLS_P = 537, + NUMERIC = 538, + OBJECT_P = 539, + OF = 540, + OFF = 541, + OFFSET = 542, + OIDS = 543, + OLD = 544, + ON = 545, + ONLY = 546, + OPERATOR = 547, + OPTION = 548, + OPTIONS = 549, + OR = 550, + ORDER = 551, + ORDINALITY = 552, + OTHERS = 553, + OUT_P = 554, + OUTER_P = 555, + OVER = 556, + OVERLAPS = 557, + OVERLAY = 558, + OVERRIDING = 559, + OWNED = 560, + OWNER = 561, + PARALLEL = 562, + PARSER = 563, + PARTIAL = 564, + PARTITION = 565, + PASSING = 566, + PASSWORD = 567, + PERCENT = 568, + PERSISTENT = 569, + PIVOT = 570, + PIVOT_LONGER = 571, + PIVOT_WIDER = 572, + PLACING = 573, + PLANS = 574, + POLICY = 575, + POSITION = 576, + POSITIONAL = 577, + PRAGMA_P = 578, + PRECEDING = 579, + PRECISION = 580, + PREPARE = 581, + PREPARED = 582, + PRESERVE = 583, + PRIMARY = 584, + PRIOR = 585, + PRIVILEGES = 586, + PROCEDURAL = 587, + PROCEDURE = 588, + PROGRAM = 589, + PUBLICATION = 590, + QUALIFY = 591, + QUARTER_P = 592, + QUARTERS_P = 593, + QUOTE = 594, + RANGE = 595, + READ_P = 596, + REAL = 597, + REASSIGN = 598, + RECHECK = 599, + RECURSIVE = 600, + REF = 601, + REFERENCES = 602, + REFERENCING = 603, + REFRESH = 604, + REINDEX = 605, + RELATIVE_P = 606, + RELEASE = 607, + RENAME = 608, + REPEATABLE = 609, + REPLACE = 610, + REPLICA = 611, + RESET = 612, + RESPECT_P = 613, + RESTART = 614, + RESTRICT = 615, + RETURNING = 616, + RETURNS = 617, + REVOKE = 618, + RIGHT = 619, + ROLE = 620, + ROLLBACK = 621, + ROLLUP = 622, + ROW = 623, + ROWS = 624, + RULE = 625, + SAMPLE = 626, + SAVEPOINT = 627, + SCHEMA = 628, + SCHEMAS = 629, + SCOPE = 630, + SCROLL = 631, + SEARCH = 632, + SECOND_P = 633, + SECONDS_P = 634, + SECRET = 635, + SECURITY = 636, + SELECT = 637, + SEMI = 638, + SEQUENCE = 639, + SEQUENCES = 640, + SERIALIZABLE = 641, + SERVER = 642, + SESSION = 643, + SET = 644, + SETOF = 645, + SETS = 646, + SHARE = 647, + SHOW = 648, + SIMILAR = 649, + SIMPLE = 650, + SKIP = 651, + SMALLINT = 652, + SNAPSHOT = 653, + SOME = 654, + SQL_P = 655, + STABLE = 656, + STANDALONE_P = 657, + START = 658, + STATEMENT = 659, + STATISTICS = 660, + STDIN = 661, + STDOUT = 662, + STORAGE = 663, + STORED = 664, + STRICT_P = 665, + STRIP_P = 666, + STRUCT = 667, + SUBSCRIPTION = 668, + SUBSTRING = 669, + SUMMARIZE = 670, + SYMMETRIC = 671, + SYSID = 672, + SYSTEM_P = 673, + TABLE = 674, + TABLES = 675, + TABLESAMPLE = 676, + TABLESPACE = 677, + TEMP = 678, + TEMPLATE = 679, + TEMPORARY = 680, + TEXT_P = 681, + THEN = 682, + TIES = 683, + TIME = 684, + TIMESTAMP = 685, + TO = 686, + TRAILING = 687, + TRANSACTION = 688, + TRANSFORM = 689, + TREAT = 690, + TRIGGER = 691, + TRIM = 692, + TRUE_P = 693, + TRUNCATE = 694, + TRUSTED = 695, + TRY_CAST = 696, + TYPE_P = 697, + TYPES_P = 698, + UNBOUNDED = 699, + UNCOMMITTED = 700, + UNENCRYPTED = 701, + UNION = 702, + UNIQUE = 703, + UNKNOWN = 704, + UNLISTEN = 705, + UNLOGGED = 706, + UNPIVOT = 707, + UNTIL = 708, + UPDATE = 709, + USE_P = 710, + USER = 711, + USING = 712, + VACUUM = 713, + VALID = 714, + VALIDATE = 715, + VALIDATOR = 716, + VALUE_P = 717, + VALUES = 718, + VARCHAR = 719, + VARIADIC = 720, + VARYING = 721, + VERBOSE = 722, + VERSION_P = 723, + VIEW = 724, + VIEWS = 725, + VIRTUAL = 726, + VOLATILE = 727, + WEEK_P = 728, + WEEKS_P = 729, + WHEN = 730, + WHERE = 731, + WHITESPACE_P = 732, + WINDOW = 733, + WITH = 734, + WITHIN = 735, + WITHOUT = 736, + WORK = 737, + WRAPPER = 738, + WRITE_P = 739, + XML_P = 740, + XMLATTRIBUTES = 741, + XMLCONCAT = 742, + XMLELEMENT = 743, + XMLEXISTS = 744, + XMLFOREST = 745, + XMLNAMESPACES = 746, + XMLPARSE = 747, + XMLPI = 748, + XMLROOT = 749, + XMLSERIALIZE = 750, + XMLTABLE = 751, + YEAR_P = 752, + YEARS_P = 753, + YES_P = 754, + ZONE = 755, + NOT_LA = 756, + NULLS_LA = 757, + WITH_LA = 758, + POSTFIXOP = 759, + UMINUS = 760 + }; +#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 EXTENSIONS 412 +#define EXTERNAL 413 +#define EXTRACT 414 +#define FALSE_P 415 +#define FAMILY 416 +#define FETCH 417 +#define FILTER 418 +#define FIRST_P 419 +#define FLOAT_P 420 +#define FOLLOWING 421 +#define FOR 422 +#define FORCE 423 +#define FOREIGN 424 +#define FORWARD 425 +#define FREEZE 426 +#define FROM 427 +#define FULL 428 +#define FUNCTION 429 +#define FUNCTIONS 430 +#define GENERATED 431 +#define GLOB 432 +#define GLOBAL 433 +#define GRANT 434 +#define GRANTED 435 +#define GROUP_P 436 +#define GROUPING 437 +#define GROUPING_ID 438 +#define GROUPS 439 +#define HANDLER 440 +#define HAVING 441 +#define HEADER_P 442 +#define HOLD 443 +#define HOUR_P 444 +#define HOURS_P 445 +#define IDENTITY_P 446 +#define IF_P 447 +#define IGNORE_P 448 +#define ILIKE 449 +#define IMMEDIATE 450 +#define IMMUTABLE 451 +#define IMPLICIT_P 452 +#define IMPORT_P 453 +#define IN_P 454 +#define INCLUDE_P 455 +#define INCLUDING 456 +#define INCREMENT 457 +#define INDEX 458 +#define INDEXES 459 +#define INHERIT 460 +#define INHERITS 461 +#define INITIALLY 462 +#define INLINE_P 463 +#define INNER_P 464 +#define INOUT 465 +#define INPUT_P 466 +#define INSENSITIVE 467 +#define INSERT 468 +#define INSTALL 469 +#define INSTEAD 470 +#define INT_P 471 +#define INTEGER 472 +#define INTERSECT 473 +#define INTERVAL 474 +#define INTO 475 +#define INVOKER 476 +#define IS 477 +#define ISNULL 478 +#define ISOLATION 479 +#define JOIN 480 +#define JSON 481 +#define KEY 482 +#define LABEL 483 +#define LANGUAGE 484 +#define LARGE_P 485 +#define LAST_P 486 +#define LATERAL_P 487 +#define LEADING 488 +#define LEAKPROOF 489 +#define LEFT 490 +#define LEVEL 491 +#define LIKE 492 +#define LIMIT 493 +#define LISTEN 494 +#define LOAD 495 +#define LOCAL 496 +#define LOCATION 497 +#define LOCK_P 498 +#define LOCKED 499 +#define LOGGED 500 +#define MACRO 501 +#define MAP 502 +#define MAPPING 503 +#define MATCH 504 +#define MATERIALIZED 505 +#define MAXVALUE 506 +#define METHOD 507 +#define MICROSECOND_P 508 +#define MICROSECONDS_P 509 +#define MILLENNIA_P 510 +#define MILLENNIUM_P 511 +#define MILLISECOND_P 512 +#define MILLISECONDS_P 513 +#define MINUTE_P 514 +#define MINUTES_P 515 +#define MINVALUE 516 +#define MODE 517 +#define MONTH_P 518 +#define MONTHS_P 519 +#define MOVE 520 +#define NAME_P 521 +#define NAMES 522 +#define NATIONAL 523 +#define NATURAL 524 +#define NCHAR 525 +#define NEW 526 +#define NEXT 527 +#define NO 528 +#define NONE 529 +#define NOT 530 +#define NOTHING 531 +#define NOTIFY 532 +#define NOTNULL 533 +#define NOWAIT 534 +#define NULL_P 535 +#define NULLIF 536 +#define NULLS_P 537 +#define NUMERIC 538 +#define OBJECT_P 539 +#define OF 540 +#define OFF 541 +#define OFFSET 542 +#define OIDS 543 +#define OLD 544 +#define ON 545 +#define ONLY 546 +#define OPERATOR 547 +#define OPTION 548 +#define OPTIONS 549 +#define OR 550 +#define ORDER 551 +#define ORDINALITY 552 +#define OTHERS 553 +#define OUT_P 554 +#define OUTER_P 555 +#define OVER 556 +#define OVERLAPS 557 +#define OVERLAY 558 +#define OVERRIDING 559 +#define OWNED 560 +#define OWNER 561 +#define PARALLEL 562 +#define PARSER 563 +#define PARTIAL 564 +#define PARTITION 565 +#define PASSING 566 +#define PASSWORD 567 +#define PERCENT 568 +#define PERSISTENT 569 +#define PIVOT 570 +#define PIVOT_LONGER 571 +#define PIVOT_WIDER 572 +#define PLACING 573 +#define PLANS 574 +#define POLICY 575 +#define POSITION 576 +#define POSITIONAL 577 +#define PRAGMA_P 578 +#define PRECEDING 579 +#define PRECISION 580 +#define PREPARE 581 +#define PREPARED 582 +#define PRESERVE 583 +#define PRIMARY 584 +#define PRIOR 585 +#define PRIVILEGES 586 +#define PROCEDURAL 587 +#define PROCEDURE 588 +#define PROGRAM 589 +#define PUBLICATION 590 +#define QUALIFY 591 +#define QUARTER_P 592 +#define QUARTERS_P 593 +#define QUOTE 594 +#define RANGE 595 +#define READ_P 596 +#define REAL 597 +#define REASSIGN 598 +#define RECHECK 599 +#define RECURSIVE 600 +#define REF 601 +#define REFERENCES 602 +#define REFERENCING 603 +#define REFRESH 604 +#define REINDEX 605 +#define RELATIVE_P 606 +#define RELEASE 607 +#define RENAME 608 +#define REPEATABLE 609 +#define REPLACE 610 +#define REPLICA 611 +#define RESET 612 +#define RESPECT_P 613 +#define RESTART 614 +#define RESTRICT 615 +#define RETURNING 616 +#define RETURNS 617 +#define REVOKE 618 +#define RIGHT 619 +#define ROLE 620 +#define ROLLBACK 621 +#define ROLLUP 622 +#define ROW 623 +#define ROWS 624 +#define RULE 625 +#define SAMPLE 626 +#define SAVEPOINT 627 +#define SCHEMA 628 +#define SCHEMAS 629 +#define SCOPE 630 +#define SCROLL 631 +#define SEARCH 632 +#define SECOND_P 633 +#define SECONDS_P 634 +#define SECRET 635 +#define SECURITY 636 +#define SELECT 637 +#define SEMI 638 +#define SEQUENCE 639 +#define SEQUENCES 640 +#define SERIALIZABLE 641 +#define SERVER 642 +#define SESSION 643 +#define SET 644 +#define SETOF 645 +#define SETS 646 +#define SHARE 647 +#define SHOW 648 +#define SIMILAR 649 +#define SIMPLE 650 +#define SKIP 651 +#define SMALLINT 652 +#define SNAPSHOT 653 +#define SOME 654 +#define SQL_P 655 +#define STABLE 656 +#define STANDALONE_P 657 +#define START 658 +#define STATEMENT 659 +#define STATISTICS 660 +#define STDIN 661 +#define STDOUT 662 +#define STORAGE 663 +#define STORED 664 +#define STRICT_P 665 +#define STRIP_P 666 +#define STRUCT 667 +#define SUBSCRIPTION 668 +#define SUBSTRING 669 +#define SUMMARIZE 670 +#define SYMMETRIC 671 +#define SYSID 672 +#define SYSTEM_P 673 +#define TABLE 674 +#define TABLES 675 +#define TABLESAMPLE 676 +#define TABLESPACE 677 +#define TEMP 678 +#define TEMPLATE 679 +#define TEMPORARY 680 +#define TEXT_P 681 +#define THEN 682 +#define TIES 683 +#define TIME 684 +#define TIMESTAMP 685 +#define TO 686 +#define TRAILING 687 +#define TRANSACTION 688 +#define TRANSFORM 689 +#define TREAT 690 +#define TRIGGER 691 +#define TRIM 692 +#define TRUE_P 693 +#define TRUNCATE 694 +#define TRUSTED 695 +#define TRY_CAST 696 +#define TYPE_P 697 +#define TYPES_P 698 +#define UNBOUNDED 699 +#define UNCOMMITTED 700 +#define UNENCRYPTED 701 +#define UNION 702 +#define UNIQUE 703 +#define UNKNOWN 704 +#define UNLISTEN 705 +#define UNLOGGED 706 +#define UNPIVOT 707 +#define UNTIL 708 +#define UPDATE 709 +#define USE_P 710 +#define USER 711 +#define USING 712 +#define VACUUM 713 +#define VALID 714 +#define VALIDATE 715 +#define VALIDATOR 716 +#define VALUE_P 717 +#define VALUES 718 +#define VARCHAR 719 +#define VARIADIC 720 +#define VARYING 721 +#define VERBOSE 722 +#define VERSION_P 723 +#define VIEW 724 +#define VIEWS 725 +#define VIRTUAL 726 +#define VOLATILE 727 +#define WEEK_P 728 +#define WEEKS_P 729 +#define WHEN 730 +#define WHERE 731 +#define WHITESPACE_P 732 +#define WINDOW 733 +#define WITH 734 +#define WITHIN 735 +#define WITHOUT 736 +#define WORK 737 +#define WRAPPER 738 +#define WRITE_P 739 +#define XML_P 740 +#define XMLATTRIBUTES 741 +#define XMLCONCAT 742 +#define XMLELEMENT 743 +#define XMLEXISTS 744 +#define XMLFOREST 745 +#define XMLNAMESPACES 746 +#define XMLPARSE 747 +#define XMLPI 748 +#define XMLROOT 749 +#define XMLSERIALIZE 750 +#define XMLTABLE 751 +#define YEAR_P 752 +#define YEARS_P 753 +#define YES_P 754 +#define ZONE 755 +#define NOT_LA 756 +#define NULLS_LA 757 +#define WITH_LA 758 +#define POSTFIXOP 759 +#define UMINUS 760 + + + + +/* 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" @@ -237,1116 +1253,135 @@ 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 -#include "include/parser/gram.hpp" -/* 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_EXTENSIONS = 157, /* EXTENSIONS */ - YYSYMBOL_EXTERNAL = 158, /* EXTERNAL */ - YYSYMBOL_EXTRACT = 159, /* EXTRACT */ - YYSYMBOL_FALSE_P = 160, /* FALSE_P */ - YYSYMBOL_FAMILY = 161, /* FAMILY */ - YYSYMBOL_FETCH = 162, /* FETCH */ - YYSYMBOL_FILTER = 163, /* FILTER */ - YYSYMBOL_FIRST_P = 164, /* FIRST_P */ - YYSYMBOL_FLOAT_P = 165, /* FLOAT_P */ - YYSYMBOL_FOLLOWING = 166, /* FOLLOWING */ - YYSYMBOL_FOR = 167, /* FOR */ - YYSYMBOL_FORCE = 168, /* FORCE */ - YYSYMBOL_FOREIGN = 169, /* FOREIGN */ - YYSYMBOL_FORWARD = 170, /* FORWARD */ - YYSYMBOL_FREEZE = 171, /* FREEZE */ - YYSYMBOL_FROM = 172, /* FROM */ - YYSYMBOL_FULL = 173, /* FULL */ - YYSYMBOL_FUNCTION = 174, /* FUNCTION */ - YYSYMBOL_FUNCTIONS = 175, /* FUNCTIONS */ - YYSYMBOL_GENERATED = 176, /* GENERATED */ - YYSYMBOL_GLOB = 177, /* GLOB */ - YYSYMBOL_GLOBAL = 178, /* GLOBAL */ - YYSYMBOL_GRANT = 179, /* GRANT */ - YYSYMBOL_GRANTED = 180, /* GRANTED */ - YYSYMBOL_GROUP_P = 181, /* GROUP_P */ - YYSYMBOL_GROUPING = 182, /* GROUPING */ - YYSYMBOL_GROUPING_ID = 183, /* GROUPING_ID */ - YYSYMBOL_GROUPS = 184, /* GROUPS */ - YYSYMBOL_HANDLER = 185, /* HANDLER */ - YYSYMBOL_HAVING = 186, /* HAVING */ - YYSYMBOL_HEADER_P = 187, /* HEADER_P */ - YYSYMBOL_HOLD = 188, /* HOLD */ - YYSYMBOL_HOUR_P = 189, /* HOUR_P */ - YYSYMBOL_HOURS_P = 190, /* HOURS_P */ - YYSYMBOL_IDENTITY_P = 191, /* IDENTITY_P */ - YYSYMBOL_IF_P = 192, /* IF_P */ - YYSYMBOL_IGNORE_P = 193, /* IGNORE_P */ - YYSYMBOL_ILIKE = 194, /* ILIKE */ - YYSYMBOL_IMMEDIATE = 195, /* IMMEDIATE */ - YYSYMBOL_IMMUTABLE = 196, /* IMMUTABLE */ - YYSYMBOL_IMPLICIT_P = 197, /* IMPLICIT_P */ - YYSYMBOL_IMPORT_P = 198, /* IMPORT_P */ - YYSYMBOL_IN_P = 199, /* IN_P */ - YYSYMBOL_INCLUDE_P = 200, /* INCLUDE_P */ - YYSYMBOL_INCLUDING = 201, /* INCLUDING */ - YYSYMBOL_INCREMENT = 202, /* INCREMENT */ - YYSYMBOL_INDEX = 203, /* INDEX */ - YYSYMBOL_INDEXES = 204, /* INDEXES */ - YYSYMBOL_INHERIT = 205, /* INHERIT */ - YYSYMBOL_INHERITS = 206, /* INHERITS */ - YYSYMBOL_INITIALLY = 207, /* INITIALLY */ - YYSYMBOL_INLINE_P = 208, /* INLINE_P */ - YYSYMBOL_INNER_P = 209, /* INNER_P */ - YYSYMBOL_INOUT = 210, /* INOUT */ - YYSYMBOL_INPUT_P = 211, /* INPUT_P */ - YYSYMBOL_INSENSITIVE = 212, /* INSENSITIVE */ - YYSYMBOL_INSERT = 213, /* INSERT */ - YYSYMBOL_INSTALL = 214, /* INSTALL */ - YYSYMBOL_INSTEAD = 215, /* INSTEAD */ - YYSYMBOL_INT_P = 216, /* INT_P */ - YYSYMBOL_INTEGER = 217, /* INTEGER */ - YYSYMBOL_INTERSECT = 218, /* INTERSECT */ - YYSYMBOL_INTERVAL = 219, /* INTERVAL */ - YYSYMBOL_INTO = 220, /* INTO */ - YYSYMBOL_INVOKER = 221, /* INVOKER */ - YYSYMBOL_IS = 222, /* IS */ - YYSYMBOL_ISNULL = 223, /* ISNULL */ - YYSYMBOL_ISOLATION = 224, /* ISOLATION */ - YYSYMBOL_JOIN = 225, /* JOIN */ - YYSYMBOL_JSON = 226, /* JSON */ - YYSYMBOL_KEY = 227, /* KEY */ - YYSYMBOL_LABEL = 228, /* LABEL */ - YYSYMBOL_LANGUAGE = 229, /* LANGUAGE */ - YYSYMBOL_LARGE_P = 230, /* LARGE_P */ - YYSYMBOL_LAST_P = 231, /* LAST_P */ - YYSYMBOL_LATERAL_P = 232, /* LATERAL_P */ - YYSYMBOL_LEADING = 233, /* LEADING */ - YYSYMBOL_LEAKPROOF = 234, /* LEAKPROOF */ - YYSYMBOL_LEFT = 235, /* LEFT */ - YYSYMBOL_LEVEL = 236, /* LEVEL */ - YYSYMBOL_LIKE = 237, /* LIKE */ - YYSYMBOL_LIMIT = 238, /* LIMIT */ - YYSYMBOL_LISTEN = 239, /* LISTEN */ - YYSYMBOL_LOAD = 240, /* LOAD */ - YYSYMBOL_LOCAL = 241, /* LOCAL */ - YYSYMBOL_LOCATION = 242, /* LOCATION */ - YYSYMBOL_LOCK_P = 243, /* LOCK_P */ - YYSYMBOL_LOCKED = 244, /* LOCKED */ - YYSYMBOL_LOGGED = 245, /* LOGGED */ - YYSYMBOL_MACRO = 246, /* MACRO */ - YYSYMBOL_MAP = 247, /* MAP */ - YYSYMBOL_MAPPING = 248, /* MAPPING */ - YYSYMBOL_MATCH = 249, /* MATCH */ - YYSYMBOL_MATERIALIZED = 250, /* MATERIALIZED */ - YYSYMBOL_MAXVALUE = 251, /* MAXVALUE */ - YYSYMBOL_METHOD = 252, /* METHOD */ - YYSYMBOL_MICROSECOND_P = 253, /* MICROSECOND_P */ - YYSYMBOL_MICROSECONDS_P = 254, /* MICROSECONDS_P */ - YYSYMBOL_MILLENNIA_P = 255, /* MILLENNIA_P */ - YYSYMBOL_MILLENNIUM_P = 256, /* MILLENNIUM_P */ - YYSYMBOL_MILLISECOND_P = 257, /* MILLISECOND_P */ - YYSYMBOL_MILLISECONDS_P = 258, /* MILLISECONDS_P */ - YYSYMBOL_MINUTE_P = 259, /* MINUTE_P */ - YYSYMBOL_MINUTES_P = 260, /* MINUTES_P */ - YYSYMBOL_MINVALUE = 261, /* MINVALUE */ - YYSYMBOL_MODE = 262, /* MODE */ - YYSYMBOL_MONTH_P = 263, /* MONTH_P */ - YYSYMBOL_MONTHS_P = 264, /* MONTHS_P */ - YYSYMBOL_MOVE = 265, /* MOVE */ - YYSYMBOL_NAME_P = 266, /* NAME_P */ - YYSYMBOL_NAMES = 267, /* NAMES */ - YYSYMBOL_NATIONAL = 268, /* NATIONAL */ - YYSYMBOL_NATURAL = 269, /* NATURAL */ - YYSYMBOL_NCHAR = 270, /* NCHAR */ - YYSYMBOL_NEW = 271, /* NEW */ - YYSYMBOL_NEXT = 272, /* NEXT */ - YYSYMBOL_NO = 273, /* NO */ - YYSYMBOL_NONE = 274, /* NONE */ - YYSYMBOL_NOT = 275, /* NOT */ - YYSYMBOL_NOTHING = 276, /* NOTHING */ - YYSYMBOL_NOTIFY = 277, /* NOTIFY */ - YYSYMBOL_NOTNULL = 278, /* NOTNULL */ - YYSYMBOL_NOWAIT = 279, /* NOWAIT */ - YYSYMBOL_NULL_P = 280, /* NULL_P */ - YYSYMBOL_NULLIF = 281, /* NULLIF */ - YYSYMBOL_NULLS_P = 282, /* NULLS_P */ - YYSYMBOL_NUMERIC = 283, /* NUMERIC */ - YYSYMBOL_OBJECT_P = 284, /* OBJECT_P */ - YYSYMBOL_OF = 285, /* OF */ - YYSYMBOL_OFF = 286, /* OFF */ - YYSYMBOL_OFFSET = 287, /* OFFSET */ - YYSYMBOL_OIDS = 288, /* OIDS */ - YYSYMBOL_OLD = 289, /* OLD */ - YYSYMBOL_ON = 290, /* ON */ - YYSYMBOL_ONLY = 291, /* ONLY */ - YYSYMBOL_OPERATOR = 292, /* OPERATOR */ - YYSYMBOL_OPTION = 293, /* OPTION */ - YYSYMBOL_OPTIONS = 294, /* OPTIONS */ - YYSYMBOL_OR = 295, /* OR */ - YYSYMBOL_ORDER = 296, /* ORDER */ - YYSYMBOL_ORDINALITY = 297, /* ORDINALITY */ - YYSYMBOL_OTHERS = 298, /* OTHERS */ - YYSYMBOL_OUT_P = 299, /* OUT_P */ - YYSYMBOL_OUTER_P = 300, /* OUTER_P */ - YYSYMBOL_OVER = 301, /* OVER */ - YYSYMBOL_OVERLAPS = 302, /* OVERLAPS */ - YYSYMBOL_OVERLAY = 303, /* OVERLAY */ - YYSYMBOL_OVERRIDING = 304, /* OVERRIDING */ - YYSYMBOL_OWNED = 305, /* OWNED */ - YYSYMBOL_OWNER = 306, /* OWNER */ - YYSYMBOL_PARALLEL = 307, /* PARALLEL */ - YYSYMBOL_PARSER = 308, /* PARSER */ - YYSYMBOL_PARTIAL = 309, /* PARTIAL */ - YYSYMBOL_PARTITION = 310, /* PARTITION */ - YYSYMBOL_PASSING = 311, /* PASSING */ - YYSYMBOL_PASSWORD = 312, /* PASSWORD */ - YYSYMBOL_PERCENT = 313, /* PERCENT */ - YYSYMBOL_PERSISTENT = 314, /* PERSISTENT */ - YYSYMBOL_PIVOT = 315, /* PIVOT */ - YYSYMBOL_PIVOT_LONGER = 316, /* PIVOT_LONGER */ - YYSYMBOL_PIVOT_WIDER = 317, /* PIVOT_WIDER */ - YYSYMBOL_PLACING = 318, /* PLACING */ - YYSYMBOL_PLANS = 319, /* PLANS */ - YYSYMBOL_POLICY = 320, /* POLICY */ - YYSYMBOL_POSITION = 321, /* POSITION */ - YYSYMBOL_POSITIONAL = 322, /* POSITIONAL */ - YYSYMBOL_PRAGMA_P = 323, /* PRAGMA_P */ - YYSYMBOL_PRECEDING = 324, /* PRECEDING */ - YYSYMBOL_PRECISION = 325, /* PRECISION */ - YYSYMBOL_PREPARE = 326, /* PREPARE */ - YYSYMBOL_PREPARED = 327, /* PREPARED */ - YYSYMBOL_PRESERVE = 328, /* PRESERVE */ - YYSYMBOL_PRIMARY = 329, /* PRIMARY */ - YYSYMBOL_PRIOR = 330, /* PRIOR */ - YYSYMBOL_PRIVILEGES = 331, /* PRIVILEGES */ - YYSYMBOL_PROCEDURAL = 332, /* PROCEDURAL */ - YYSYMBOL_PROCEDURE = 333, /* PROCEDURE */ - YYSYMBOL_PROGRAM = 334, /* PROGRAM */ - YYSYMBOL_PUBLICATION = 335, /* PUBLICATION */ - YYSYMBOL_QUALIFY = 336, /* QUALIFY */ - YYSYMBOL_QUARTER_P = 337, /* QUARTER_P */ - YYSYMBOL_QUARTERS_P = 338, /* QUARTERS_P */ - YYSYMBOL_QUOTE = 339, /* QUOTE */ - YYSYMBOL_RANGE = 340, /* RANGE */ - YYSYMBOL_READ_P = 341, /* READ_P */ - YYSYMBOL_REAL = 342, /* REAL */ - YYSYMBOL_REASSIGN = 343, /* REASSIGN */ - YYSYMBOL_RECHECK = 344, /* RECHECK */ - YYSYMBOL_RECURSIVE = 345, /* RECURSIVE */ - YYSYMBOL_REF = 346, /* REF */ - YYSYMBOL_REFERENCES = 347, /* REFERENCES */ - YYSYMBOL_REFERENCING = 348, /* REFERENCING */ - YYSYMBOL_REFRESH = 349, /* REFRESH */ - YYSYMBOL_REINDEX = 350, /* REINDEX */ - YYSYMBOL_RELATIVE_P = 351, /* RELATIVE_P */ - YYSYMBOL_RELEASE = 352, /* RELEASE */ - YYSYMBOL_RENAME = 353, /* RENAME */ - YYSYMBOL_REPEATABLE = 354, /* REPEATABLE */ - YYSYMBOL_REPLACE = 355, /* REPLACE */ - YYSYMBOL_REPLICA = 356, /* REPLICA */ - YYSYMBOL_RESET = 357, /* RESET */ - YYSYMBOL_RESPECT_P = 358, /* RESPECT_P */ - YYSYMBOL_RESTART = 359, /* RESTART */ - YYSYMBOL_RESTRICT = 360, /* RESTRICT */ - YYSYMBOL_RETURNING = 361, /* RETURNING */ - YYSYMBOL_RETURNS = 362, /* RETURNS */ - YYSYMBOL_REVOKE = 363, /* REVOKE */ - YYSYMBOL_RIGHT = 364, /* RIGHT */ - YYSYMBOL_ROLE = 365, /* ROLE */ - YYSYMBOL_ROLLBACK = 366, /* ROLLBACK */ - YYSYMBOL_ROLLUP = 367, /* ROLLUP */ - YYSYMBOL_ROW = 368, /* ROW */ - YYSYMBOL_ROWS = 369, /* ROWS */ - YYSYMBOL_RULE = 370, /* RULE */ - YYSYMBOL_SAMPLE = 371, /* SAMPLE */ - YYSYMBOL_SAVEPOINT = 372, /* SAVEPOINT */ - YYSYMBOL_SCHEMA = 373, /* SCHEMA */ - YYSYMBOL_SCHEMAS = 374, /* SCHEMAS */ - YYSYMBOL_SCOPE = 375, /* SCOPE */ - YYSYMBOL_SCROLL = 376, /* SCROLL */ - YYSYMBOL_SEARCH = 377, /* SEARCH */ - YYSYMBOL_SECOND_P = 378, /* SECOND_P */ - YYSYMBOL_SECONDS_P = 379, /* SECONDS_P */ - YYSYMBOL_SECRET = 380, /* SECRET */ - YYSYMBOL_SECURITY = 381, /* SECURITY */ - YYSYMBOL_SELECT = 382, /* SELECT */ - YYSYMBOL_SEMI = 383, /* SEMI */ - YYSYMBOL_SEQUENCE = 384, /* SEQUENCE */ - YYSYMBOL_SEQUENCES = 385, /* SEQUENCES */ - YYSYMBOL_SERIALIZABLE = 386, /* SERIALIZABLE */ - YYSYMBOL_SERVER = 387, /* SERVER */ - YYSYMBOL_SESSION = 388, /* SESSION */ - YYSYMBOL_SET = 389, /* SET */ - YYSYMBOL_SETOF = 390, /* SETOF */ - YYSYMBOL_SETS = 391, /* SETS */ - YYSYMBOL_SHARE = 392, /* SHARE */ - YYSYMBOL_SHOW = 393, /* SHOW */ - YYSYMBOL_SIMILAR = 394, /* SIMILAR */ - YYSYMBOL_SIMPLE = 395, /* SIMPLE */ - YYSYMBOL_SKIP = 396, /* SKIP */ - YYSYMBOL_SMALLINT = 397, /* SMALLINT */ - YYSYMBOL_SNAPSHOT = 398, /* SNAPSHOT */ - YYSYMBOL_SOME = 399, /* SOME */ - YYSYMBOL_SQL_P = 400, /* SQL_P */ - YYSYMBOL_STABLE = 401, /* STABLE */ - YYSYMBOL_STANDALONE_P = 402, /* STANDALONE_P */ - YYSYMBOL_START = 403, /* START */ - YYSYMBOL_STATEMENT = 404, /* STATEMENT */ - YYSYMBOL_STATISTICS = 405, /* STATISTICS */ - YYSYMBOL_STDIN = 406, /* STDIN */ - YYSYMBOL_STDOUT = 407, /* STDOUT */ - YYSYMBOL_STORAGE = 408, /* STORAGE */ - YYSYMBOL_STORED = 409, /* STORED */ - YYSYMBOL_STRICT_P = 410, /* STRICT_P */ - YYSYMBOL_STRIP_P = 411, /* STRIP_P */ - YYSYMBOL_STRUCT = 412, /* STRUCT */ - YYSYMBOL_SUBSCRIPTION = 413, /* SUBSCRIPTION */ - YYSYMBOL_SUBSTRING = 414, /* SUBSTRING */ - YYSYMBOL_SUMMARIZE = 415, /* SUMMARIZE */ - YYSYMBOL_SYMMETRIC = 416, /* SYMMETRIC */ - YYSYMBOL_SYSID = 417, /* SYSID */ - YYSYMBOL_SYSTEM_P = 418, /* SYSTEM_P */ - YYSYMBOL_TABLE = 419, /* TABLE */ - YYSYMBOL_TABLES = 420, /* TABLES */ - YYSYMBOL_TABLESAMPLE = 421, /* TABLESAMPLE */ - YYSYMBOL_TABLESPACE = 422, /* TABLESPACE */ - YYSYMBOL_TEMP = 423, /* TEMP */ - YYSYMBOL_TEMPLATE = 424, /* TEMPLATE */ - YYSYMBOL_TEMPORARY = 425, /* TEMPORARY */ - YYSYMBOL_TEXT_P = 426, /* TEXT_P */ - YYSYMBOL_THEN = 427, /* THEN */ - YYSYMBOL_TIES = 428, /* TIES */ - YYSYMBOL_TIME = 429, /* TIME */ - YYSYMBOL_TIMESTAMP = 430, /* TIMESTAMP */ - YYSYMBOL_TO = 431, /* TO */ - YYSYMBOL_TRAILING = 432, /* TRAILING */ - YYSYMBOL_TRANSACTION = 433, /* TRANSACTION */ - YYSYMBOL_TRANSFORM = 434, /* TRANSFORM */ - YYSYMBOL_TREAT = 435, /* TREAT */ - YYSYMBOL_TRIGGER = 436, /* TRIGGER */ - YYSYMBOL_TRIM = 437, /* TRIM */ - YYSYMBOL_TRUE_P = 438, /* TRUE_P */ - YYSYMBOL_TRUNCATE = 439, /* TRUNCATE */ - YYSYMBOL_TRUSTED = 440, /* TRUSTED */ - YYSYMBOL_TRY_CAST = 441, /* TRY_CAST */ - YYSYMBOL_TYPE_P = 442, /* TYPE_P */ - YYSYMBOL_TYPES_P = 443, /* TYPES_P */ - YYSYMBOL_UNBOUNDED = 444, /* UNBOUNDED */ - YYSYMBOL_UNCOMMITTED = 445, /* UNCOMMITTED */ - YYSYMBOL_UNENCRYPTED = 446, /* UNENCRYPTED */ - YYSYMBOL_UNION = 447, /* UNION */ - YYSYMBOL_UNIQUE = 448, /* UNIQUE */ - YYSYMBOL_UNKNOWN = 449, /* UNKNOWN */ - YYSYMBOL_UNLISTEN = 450, /* UNLISTEN */ - YYSYMBOL_UNLOGGED = 451, /* UNLOGGED */ - YYSYMBOL_UNPIVOT = 452, /* UNPIVOT */ - YYSYMBOL_UNTIL = 453, /* UNTIL */ - YYSYMBOL_UPDATE = 454, /* UPDATE */ - YYSYMBOL_USE_P = 455, /* USE_P */ - YYSYMBOL_USER = 456, /* USER */ - YYSYMBOL_USING = 457, /* USING */ - YYSYMBOL_VACUUM = 458, /* VACUUM */ - YYSYMBOL_VALID = 459, /* VALID */ - YYSYMBOL_VALIDATE = 460, /* VALIDATE */ - YYSYMBOL_VALIDATOR = 461, /* VALIDATOR */ - YYSYMBOL_VALUE_P = 462, /* VALUE_P */ - YYSYMBOL_VALUES = 463, /* VALUES */ - YYSYMBOL_VARCHAR = 464, /* VARCHAR */ - YYSYMBOL_VARIADIC = 465, /* VARIADIC */ - YYSYMBOL_VARYING = 466, /* VARYING */ - YYSYMBOL_VERBOSE = 467, /* VERBOSE */ - YYSYMBOL_VERSION_P = 468, /* VERSION_P */ - YYSYMBOL_VIEW = 469, /* VIEW */ - YYSYMBOL_VIEWS = 470, /* VIEWS */ - YYSYMBOL_VIRTUAL = 471, /* VIRTUAL */ - YYSYMBOL_VOLATILE = 472, /* VOLATILE */ - YYSYMBOL_WEEK_P = 473, /* WEEK_P */ - YYSYMBOL_WEEKS_P = 474, /* WEEKS_P */ - YYSYMBOL_WHEN = 475, /* WHEN */ - YYSYMBOL_WHERE = 476, /* WHERE */ - YYSYMBOL_WHITESPACE_P = 477, /* WHITESPACE_P */ - YYSYMBOL_WINDOW = 478, /* WINDOW */ - YYSYMBOL_WITH = 479, /* WITH */ - YYSYMBOL_WITHIN = 480, /* WITHIN */ - YYSYMBOL_WITHOUT = 481, /* WITHOUT */ - YYSYMBOL_WORK = 482, /* WORK */ - YYSYMBOL_WRAPPER = 483, /* WRAPPER */ - YYSYMBOL_WRITE_P = 484, /* WRITE_P */ - YYSYMBOL_XML_P = 485, /* XML_P */ - YYSYMBOL_XMLATTRIBUTES = 486, /* XMLATTRIBUTES */ - YYSYMBOL_XMLCONCAT = 487, /* XMLCONCAT */ - YYSYMBOL_XMLELEMENT = 488, /* XMLELEMENT */ - YYSYMBOL_XMLEXISTS = 489, /* XMLEXISTS */ - YYSYMBOL_XMLFOREST = 490, /* XMLFOREST */ - YYSYMBOL_XMLNAMESPACES = 491, /* XMLNAMESPACES */ - YYSYMBOL_XMLPARSE = 492, /* XMLPARSE */ - YYSYMBOL_XMLPI = 493, /* XMLPI */ - YYSYMBOL_XMLROOT = 494, /* XMLROOT */ - YYSYMBOL_XMLSERIALIZE = 495, /* XMLSERIALIZE */ - YYSYMBOL_XMLTABLE = 496, /* XMLTABLE */ - YYSYMBOL_YEAR_P = 497, /* YEAR_P */ - YYSYMBOL_YEARS_P = 498, /* YEARS_P */ - YYSYMBOL_YES_P = 499, /* YES_P */ - YYSYMBOL_ZONE = 500, /* ZONE */ - YYSYMBOL_NOT_LA = 501, /* NOT_LA */ - YYSYMBOL_NULLS_LA = 502, /* NULLS_LA */ - YYSYMBOL_WITH_LA = 503, /* WITH_LA */ - YYSYMBOL_504_ = 504, /* '<' */ - YYSYMBOL_505_ = 505, /* '>' */ - YYSYMBOL_506_ = 506, /* '=' */ - YYSYMBOL_POSTFIXOP = 507, /* POSTFIXOP */ - YYSYMBOL_508_ = 508, /* '+' */ - YYSYMBOL_509_ = 509, /* '-' */ - YYSYMBOL_510_ = 510, /* '*' */ - YYSYMBOL_511_ = 511, /* '/' */ - YYSYMBOL_512_ = 512, /* '%' */ - YYSYMBOL_513_ = 513, /* '^' */ - YYSYMBOL_UMINUS = 514, /* UMINUS */ - 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_525_ = 525, /* '#' */ - YYSYMBOL_526_ = 526, /* '$' */ - YYSYMBOL_527_ = 527, /* ':' */ - YYSYMBOL_YYACCEPT = 528, /* $accept */ - YYSYMBOL_stmtblock = 529, /* stmtblock */ - YYSYMBOL_stmtmulti = 530, /* stmtmulti */ - YYSYMBOL_stmt = 531, /* stmt */ - YYSYMBOL_AlterObjectSchemaStmt = 532, /* AlterObjectSchemaStmt */ - YYSYMBOL_AlterSeqStmt = 533, /* AlterSeqStmt */ - YYSYMBOL_SeqOptList = 534, /* SeqOptList */ - YYSYMBOL_opt_with = 535, /* opt_with */ - YYSYMBOL_NumericOnly = 536, /* NumericOnly */ - YYSYMBOL_SeqOptElem = 537, /* SeqOptElem */ - YYSYMBOL_opt_by = 538, /* opt_by */ - YYSYMBOL_SignedIconst = 539, /* SignedIconst */ - YYSYMBOL_AlterTableStmt = 540, /* AlterTableStmt */ - YYSYMBOL_alter_identity_column_option_list = 541, /* alter_identity_column_option_list */ - YYSYMBOL_alter_column_default = 542, /* alter_column_default */ - YYSYMBOL_alter_identity_column_option = 543, /* alter_identity_column_option */ - YYSYMBOL_alter_generic_option_list = 544, /* alter_generic_option_list */ - YYSYMBOL_alter_table_cmd = 545, /* alter_table_cmd */ - YYSYMBOL_alter_using = 546, /* alter_using */ - YYSYMBOL_alter_generic_option_elem = 547, /* alter_generic_option_elem */ - YYSYMBOL_alter_table_cmds = 548, /* alter_table_cmds */ - YYSYMBOL_alter_generic_options = 549, /* alter_generic_options */ - YYSYMBOL_opt_set_data = 550, /* opt_set_data */ - YYSYMBOL_AnalyzeStmt = 551, /* AnalyzeStmt */ - YYSYMBOL_AttachStmt = 552, /* AttachStmt */ - YYSYMBOL_DetachStmt = 553, /* DetachStmt */ - YYSYMBOL_opt_database = 554, /* opt_database */ - YYSYMBOL_opt_database_alias = 555, /* opt_database_alias */ - YYSYMBOL_CallStmt = 556, /* CallStmt */ - YYSYMBOL_CheckPointStmt = 557, /* CheckPointStmt */ - YYSYMBOL_opt_col_id = 558, /* opt_col_id */ - YYSYMBOL_CommentOnStmt = 559, /* CommentOnStmt */ - YYSYMBOL_comment_value = 560, /* comment_value */ - YYSYMBOL_comment_on_type_any_name = 561, /* comment_on_type_any_name */ - YYSYMBOL_qualified_name = 562, /* qualified_name */ - YYSYMBOL_ColId = 563, /* ColId */ - YYSYMBOL_ColIdOrString = 564, /* ColIdOrString */ - YYSYMBOL_Sconst = 565, /* Sconst */ - YYSYMBOL_indirection = 566, /* indirection */ - YYSYMBOL_indirection_el = 567, /* indirection_el */ - YYSYMBOL_attr_name = 568, /* attr_name */ - YYSYMBOL_ColLabel = 569, /* ColLabel */ - YYSYMBOL_CopyStmt = 570, /* CopyStmt */ - YYSYMBOL_copy_database_flag = 571, /* copy_database_flag */ - YYSYMBOL_copy_from = 572, /* copy_from */ - YYSYMBOL_copy_delimiter = 573, /* copy_delimiter */ - YYSYMBOL_copy_generic_opt_arg_list = 574, /* copy_generic_opt_arg_list */ - YYSYMBOL_opt_using = 575, /* opt_using */ - YYSYMBOL_opt_as = 576, /* opt_as */ - YYSYMBOL_opt_program = 577, /* opt_program */ - YYSYMBOL_copy_options = 578, /* copy_options */ - YYSYMBOL_copy_generic_opt_arg = 579, /* copy_generic_opt_arg */ - YYSYMBOL_copy_generic_opt_elem = 580, /* copy_generic_opt_elem */ - YYSYMBOL_opt_oids = 581, /* opt_oids */ - YYSYMBOL_copy_opt_list = 582, /* copy_opt_list */ - YYSYMBOL_opt_binary = 583, /* opt_binary */ - YYSYMBOL_copy_opt_item = 584, /* copy_opt_item */ - YYSYMBOL_copy_generic_opt_arg_list_item = 585, /* copy_generic_opt_arg_list_item */ - YYSYMBOL_copy_file_name = 586, /* copy_file_name */ - YYSYMBOL_copy_generic_opt_list = 587, /* copy_generic_opt_list */ - YYSYMBOL_CreateStmt = 588, /* CreateStmt */ - YYSYMBOL_ConstraintAttributeSpec = 589, /* ConstraintAttributeSpec */ - YYSYMBOL_def_arg = 590, /* def_arg */ - YYSYMBOL_OptParenthesizedSeqOptList = 591, /* OptParenthesizedSeqOptList */ - YYSYMBOL_generic_option_arg = 592, /* generic_option_arg */ - YYSYMBOL_key_action = 593, /* key_action */ - YYSYMBOL_ColConstraint = 594, /* ColConstraint */ - YYSYMBOL_ColConstraintElem = 595, /* ColConstraintElem */ - YYSYMBOL_GeneratedColumnType = 596, /* GeneratedColumnType */ - YYSYMBOL_opt_GeneratedColumnType = 597, /* opt_GeneratedColumnType */ - YYSYMBOL_GeneratedConstraintElem = 598, /* GeneratedConstraintElem */ - YYSYMBOL_generic_option_elem = 599, /* generic_option_elem */ - YYSYMBOL_key_update = 600, /* key_update */ - YYSYMBOL_key_actions = 601, /* key_actions */ - YYSYMBOL_OnCommitOption = 602, /* OnCommitOption */ - YYSYMBOL_reloptions = 603, /* reloptions */ - YYSYMBOL_opt_no_inherit = 604, /* opt_no_inherit */ - YYSYMBOL_TableConstraint = 605, /* TableConstraint */ - YYSYMBOL_TableLikeOption = 606, /* TableLikeOption */ - YYSYMBOL_reloption_list = 607, /* reloption_list */ - YYSYMBOL_ExistingIndex = 608, /* ExistingIndex */ - YYSYMBOL_ConstraintAttr = 609, /* ConstraintAttr */ - YYSYMBOL_OptWith = 610, /* OptWith */ - YYSYMBOL_definition = 611, /* definition */ - YYSYMBOL_TableLikeOptionList = 612, /* TableLikeOptionList */ - YYSYMBOL_generic_option_name = 613, /* generic_option_name */ - YYSYMBOL_ConstraintAttributeElem = 614, /* ConstraintAttributeElem */ - YYSYMBOL_columnDef = 615, /* columnDef */ - YYSYMBOL_def_list = 616, /* def_list */ - YYSYMBOL_index_name = 617, /* index_name */ - YYSYMBOL_TableElement = 618, /* TableElement */ - YYSYMBOL_def_elem = 619, /* def_elem */ - YYSYMBOL_opt_definition = 620, /* opt_definition */ - YYSYMBOL_OptTableElementList = 621, /* OptTableElementList */ - YYSYMBOL_columnElem = 622, /* columnElem */ - YYSYMBOL_opt_column_list = 623, /* opt_column_list */ - YYSYMBOL_ColQualList = 624, /* ColQualList */ - YYSYMBOL_key_delete = 625, /* key_delete */ - YYSYMBOL_reloption_elem = 626, /* reloption_elem */ - YYSYMBOL_columnList = 627, /* columnList */ - YYSYMBOL_columnList_opt_comma = 628, /* columnList_opt_comma */ - YYSYMBOL_func_type = 629, /* func_type */ - YYSYMBOL_ConstraintElem = 630, /* ConstraintElem */ - YYSYMBOL_TableElementList = 631, /* TableElementList */ - YYSYMBOL_key_match = 632, /* key_match */ - YYSYMBOL_TableLikeClause = 633, /* TableLikeClause */ - YYSYMBOL_OptTemp = 634, /* OptTemp */ - YYSYMBOL_generated_when = 635, /* generated_when */ - YYSYMBOL_CreateAsStmt = 636, /* CreateAsStmt */ - YYSYMBOL_opt_with_data = 637, /* opt_with_data */ - YYSYMBOL_create_as_target = 638, /* create_as_target */ - YYSYMBOL_unreserved_keyword = 639, /* unreserved_keyword */ - YYSYMBOL_col_name_keyword = 640, /* col_name_keyword */ - YYSYMBOL_func_name_keyword = 641, /* func_name_keyword */ - YYSYMBOL_type_name_keyword = 642, /* type_name_keyword */ - YYSYMBOL_other_keyword = 643, /* other_keyword */ - YYSYMBOL_type_func_name_keyword = 644, /* type_func_name_keyword */ - YYSYMBOL_reserved_keyword = 645, /* reserved_keyword */ - YYSYMBOL_CreateFunctionStmt = 646, /* CreateFunctionStmt */ - YYSYMBOL_macro_alias = 647, /* macro_alias */ - YYSYMBOL_param_list = 648, /* param_list */ - YYSYMBOL_CreateSchemaStmt = 649, /* CreateSchemaStmt */ - YYSYMBOL_OptSchemaEltList = 650, /* OptSchemaEltList */ - YYSYMBOL_schema_stmt = 651, /* schema_stmt */ - YYSYMBOL_CreateSecretStmt = 652, /* CreateSecretStmt */ - YYSYMBOL_opt_secret_name = 653, /* opt_secret_name */ - YYSYMBOL_opt_persist = 654, /* opt_persist */ - YYSYMBOL_opt_storage_specifier = 655, /* opt_storage_specifier */ - YYSYMBOL_CreateSeqStmt = 656, /* CreateSeqStmt */ - YYSYMBOL_OptSeqOptList = 657, /* OptSeqOptList */ - YYSYMBOL_CreateTypeStmt = 658, /* CreateTypeStmt */ - YYSYMBOL_opt_enum_val_list = 659, /* opt_enum_val_list */ - YYSYMBOL_enum_val_list = 660, /* enum_val_list */ - YYSYMBOL_DeallocateStmt = 661, /* DeallocateStmt */ - YYSYMBOL_DeleteStmt = 662, /* DeleteStmt */ - YYSYMBOL_relation_expr_opt_alias = 663, /* relation_expr_opt_alias */ - YYSYMBOL_where_or_current_clause = 664, /* where_or_current_clause */ - YYSYMBOL_using_clause = 665, /* using_clause */ - YYSYMBOL_DropStmt = 666, /* DropStmt */ - YYSYMBOL_drop_type_any_name = 667, /* drop_type_any_name */ - YYSYMBOL_drop_type_name = 668, /* drop_type_name */ - YYSYMBOL_any_name_list = 669, /* any_name_list */ - YYSYMBOL_opt_drop_behavior = 670, /* opt_drop_behavior */ - YYSYMBOL_drop_type_name_on_any_name = 671, /* drop_type_name_on_any_name */ - YYSYMBOL_DropSecretStmt = 672, /* DropSecretStmt */ - YYSYMBOL_opt_storage_drop_specifier = 673, /* opt_storage_drop_specifier */ - YYSYMBOL_ExecuteStmt = 674, /* ExecuteStmt */ - YYSYMBOL_execute_param_expr = 675, /* execute_param_expr */ - YYSYMBOL_execute_param_list = 676, /* execute_param_list */ - YYSYMBOL_execute_param_clause = 677, /* execute_param_clause */ - YYSYMBOL_ExplainStmt = 678, /* ExplainStmt */ - YYSYMBOL_opt_verbose = 679, /* opt_verbose */ - YYSYMBOL_explain_option_arg = 680, /* explain_option_arg */ - YYSYMBOL_ExplainableStmt = 681, /* ExplainableStmt */ - YYSYMBOL_NonReservedWord = 682, /* NonReservedWord */ - YYSYMBOL_NonReservedWord_or_Sconst = 683, /* NonReservedWord_or_Sconst */ - YYSYMBOL_explain_option_list = 684, /* explain_option_list */ - YYSYMBOL_analyze_keyword = 685, /* analyze_keyword */ - YYSYMBOL_opt_boolean_or_string = 686, /* opt_boolean_or_string */ - YYSYMBOL_explain_option_elem = 687, /* explain_option_elem */ - YYSYMBOL_explain_option_name = 688, /* explain_option_name */ - YYSYMBOL_ExportStmt = 689, /* ExportStmt */ - YYSYMBOL_ImportStmt = 690, /* ImportStmt */ - YYSYMBOL_IndexStmt = 691, /* IndexStmt */ - YYSYMBOL_access_method = 692, /* access_method */ - YYSYMBOL_access_method_clause = 693, /* access_method_clause */ - YYSYMBOL_opt_concurrently = 694, /* opt_concurrently */ - YYSYMBOL_opt_index_name = 695, /* opt_index_name */ - YYSYMBOL_opt_reloptions = 696, /* opt_reloptions */ - YYSYMBOL_opt_unique = 697, /* opt_unique */ - YYSYMBOL_InsertStmt = 698, /* InsertStmt */ - YYSYMBOL_insert_rest = 699, /* insert_rest */ - YYSYMBOL_insert_target = 700, /* insert_target */ - YYSYMBOL_opt_by_name_or_position = 701, /* opt_by_name_or_position */ - YYSYMBOL_opt_conf_expr = 702, /* opt_conf_expr */ - YYSYMBOL_opt_with_clause = 703, /* opt_with_clause */ - YYSYMBOL_insert_column_item = 704, /* insert_column_item */ - YYSYMBOL_set_clause = 705, /* set_clause */ - YYSYMBOL_opt_or_action = 706, /* opt_or_action */ - YYSYMBOL_opt_on_conflict = 707, /* opt_on_conflict */ - YYSYMBOL_index_elem = 708, /* index_elem */ - YYSYMBOL_returning_clause = 709, /* returning_clause */ - YYSYMBOL_override_kind = 710, /* override_kind */ - YYSYMBOL_set_target_list = 711, /* set_target_list */ - YYSYMBOL_opt_collate = 712, /* opt_collate */ - YYSYMBOL_opt_class = 713, /* opt_class */ - YYSYMBOL_insert_column_list = 714, /* insert_column_list */ - YYSYMBOL_set_clause_list = 715, /* set_clause_list */ - YYSYMBOL_set_clause_list_opt_comma = 716, /* set_clause_list_opt_comma */ - YYSYMBOL_index_params = 717, /* index_params */ - YYSYMBOL_set_target = 718, /* set_target */ - YYSYMBOL_LoadStmt = 719, /* LoadStmt */ - YYSYMBOL_opt_force = 720, /* opt_force */ - YYSYMBOL_file_name = 721, /* file_name */ - YYSYMBOL_opt_ext_version = 722, /* opt_ext_version */ - YYSYMBOL_PragmaStmt = 723, /* PragmaStmt */ - YYSYMBOL_PrepareStmt = 724, /* PrepareStmt */ - YYSYMBOL_prep_type_clause = 725, /* prep_type_clause */ - YYSYMBOL_PreparableStmt = 726, /* PreparableStmt */ - YYSYMBOL_RenameStmt = 727, /* RenameStmt */ - YYSYMBOL_opt_column = 728, /* opt_column */ - YYSYMBOL_SelectStmt = 729, /* SelectStmt */ - YYSYMBOL_select_with_parens = 730, /* select_with_parens */ - YYSYMBOL_select_no_parens = 731, /* select_no_parens */ - YYSYMBOL_select_clause = 732, /* select_clause */ - YYSYMBOL_opt_select = 733, /* opt_select */ - YYSYMBOL_simple_select = 734, /* simple_select */ - YYSYMBOL_value_or_values = 735, /* value_or_values */ - YYSYMBOL_pivot_keyword = 736, /* pivot_keyword */ - YYSYMBOL_unpivot_keyword = 737, /* unpivot_keyword */ - YYSYMBOL_pivot_column_entry = 738, /* pivot_column_entry */ - YYSYMBOL_pivot_column_list_internal = 739, /* pivot_column_list_internal */ - YYSYMBOL_pivot_column_list = 740, /* pivot_column_list */ - YYSYMBOL_with_clause = 741, /* with_clause */ - YYSYMBOL_cte_list = 742, /* cte_list */ - YYSYMBOL_common_table_expr = 743, /* common_table_expr */ - YYSYMBOL_opt_materialized = 744, /* opt_materialized */ - YYSYMBOL_into_clause = 745, /* into_clause */ - YYSYMBOL_OptTempTableName = 746, /* OptTempTableName */ - YYSYMBOL_opt_table = 747, /* opt_table */ - YYSYMBOL_all_or_distinct = 748, /* all_or_distinct */ - YYSYMBOL_by_name = 749, /* by_name */ - YYSYMBOL_distinct_clause = 750, /* distinct_clause */ - YYSYMBOL_opt_all_clause = 751, /* opt_all_clause */ - YYSYMBOL_opt_ignore_nulls = 752, /* opt_ignore_nulls */ - YYSYMBOL_opt_sort_clause = 753, /* opt_sort_clause */ - YYSYMBOL_sort_clause = 754, /* sort_clause */ - YYSYMBOL_sortby_list = 755, /* sortby_list */ - YYSYMBOL_sortby = 756, /* sortby */ - YYSYMBOL_opt_asc_desc = 757, /* opt_asc_desc */ - YYSYMBOL_opt_nulls_order = 758, /* opt_nulls_order */ - YYSYMBOL_select_limit = 759, /* select_limit */ - YYSYMBOL_opt_select_limit = 760, /* opt_select_limit */ - YYSYMBOL_limit_clause = 761, /* limit_clause */ - YYSYMBOL_offset_clause = 762, /* offset_clause */ - YYSYMBOL_sample_count = 763, /* sample_count */ - YYSYMBOL_sample_clause = 764, /* sample_clause */ - YYSYMBOL_opt_sample_func = 765, /* opt_sample_func */ - YYSYMBOL_tablesample_entry = 766, /* tablesample_entry */ - YYSYMBOL_tablesample_clause = 767, /* tablesample_clause */ - YYSYMBOL_opt_tablesample_clause = 768, /* opt_tablesample_clause */ - YYSYMBOL_opt_repeatable_clause = 769, /* opt_repeatable_clause */ - YYSYMBOL_select_limit_value = 770, /* select_limit_value */ - YYSYMBOL_select_offset_value = 771, /* select_offset_value */ - YYSYMBOL_select_fetch_first_value = 772, /* select_fetch_first_value */ - YYSYMBOL_I_or_F_const = 773, /* I_or_F_const */ - YYSYMBOL_row_or_rows = 774, /* row_or_rows */ - YYSYMBOL_first_or_next = 775, /* first_or_next */ - YYSYMBOL_group_clause = 776, /* group_clause */ - YYSYMBOL_group_by_list = 777, /* group_by_list */ - YYSYMBOL_group_by_list_opt_comma = 778, /* group_by_list_opt_comma */ - YYSYMBOL_group_by_item = 779, /* group_by_item */ - YYSYMBOL_empty_grouping_set = 780, /* empty_grouping_set */ - YYSYMBOL_rollup_clause = 781, /* rollup_clause */ - YYSYMBOL_cube_clause = 782, /* cube_clause */ - YYSYMBOL_grouping_sets_clause = 783, /* grouping_sets_clause */ - YYSYMBOL_grouping_or_grouping_id = 784, /* grouping_or_grouping_id */ - YYSYMBOL_having_clause = 785, /* having_clause */ - YYSYMBOL_qualify_clause = 786, /* qualify_clause */ - YYSYMBOL_for_locking_clause = 787, /* for_locking_clause */ - YYSYMBOL_opt_for_locking_clause = 788, /* opt_for_locking_clause */ - YYSYMBOL_for_locking_items = 789, /* for_locking_items */ - YYSYMBOL_for_locking_item = 790, /* for_locking_item */ - YYSYMBOL_for_locking_strength = 791, /* for_locking_strength */ - YYSYMBOL_locked_rels_list = 792, /* locked_rels_list */ - YYSYMBOL_opt_nowait_or_skip = 793, /* opt_nowait_or_skip */ - YYSYMBOL_values_clause = 794, /* values_clause */ - YYSYMBOL_values_clause_opt_comma = 795, /* values_clause_opt_comma */ - YYSYMBOL_from_clause = 796, /* from_clause */ - YYSYMBOL_from_list = 797, /* from_list */ - YYSYMBOL_from_list_opt_comma = 798, /* from_list_opt_comma */ - YYSYMBOL_table_ref = 799, /* table_ref */ - YYSYMBOL_opt_pivot_group_by = 800, /* opt_pivot_group_by */ - YYSYMBOL_opt_include_nulls = 801, /* opt_include_nulls */ - YYSYMBOL_single_pivot_value = 802, /* single_pivot_value */ - YYSYMBOL_pivot_header = 803, /* pivot_header */ - YYSYMBOL_pivot_value = 804, /* pivot_value */ - YYSYMBOL_pivot_value_list = 805, /* pivot_value_list */ - YYSYMBOL_unpivot_header = 806, /* unpivot_header */ - YYSYMBOL_unpivot_value = 807, /* unpivot_value */ - YYSYMBOL_unpivot_value_list = 808, /* unpivot_value_list */ - YYSYMBOL_joined_table = 809, /* joined_table */ - YYSYMBOL_alias_clause = 810, /* alias_clause */ - YYSYMBOL_opt_alias_clause = 811, /* opt_alias_clause */ - YYSYMBOL_func_alias_clause = 812, /* func_alias_clause */ - YYSYMBOL_join_type = 813, /* join_type */ - YYSYMBOL_join_outer = 814, /* join_outer */ - YYSYMBOL_join_qual = 815, /* join_qual */ - YYSYMBOL_relation_expr = 816, /* relation_expr */ - YYSYMBOL_func_table = 817, /* func_table */ - YYSYMBOL_rowsfrom_item = 818, /* rowsfrom_item */ - YYSYMBOL_rowsfrom_list = 819, /* rowsfrom_list */ - YYSYMBOL_opt_col_def_list = 820, /* opt_col_def_list */ - YYSYMBOL_opt_ordinality = 821, /* opt_ordinality */ - YYSYMBOL_where_clause = 822, /* where_clause */ - YYSYMBOL_TableFuncElementList = 823, /* TableFuncElementList */ - YYSYMBOL_TableFuncElement = 824, /* TableFuncElement */ - YYSYMBOL_opt_collate_clause = 825, /* opt_collate_clause */ - YYSYMBOL_colid_type_list = 826, /* colid_type_list */ - YYSYMBOL_RowOrStruct = 827, /* RowOrStruct */ - YYSYMBOL_opt_Typename = 828, /* opt_Typename */ - YYSYMBOL_Typename = 829, /* Typename */ - YYSYMBOL_qualified_typename = 830, /* qualified_typename */ - YYSYMBOL_opt_array_bounds = 831, /* opt_array_bounds */ - YYSYMBOL_SimpleTypename = 832, /* SimpleTypename */ - YYSYMBOL_ConstTypename = 833, /* ConstTypename */ - YYSYMBOL_GenericType = 834, /* GenericType */ - YYSYMBOL_opt_type_modifiers = 835, /* opt_type_modifiers */ - YYSYMBOL_Numeric = 836, /* Numeric */ - YYSYMBOL_opt_float = 837, /* opt_float */ - YYSYMBOL_Bit = 838, /* Bit */ - YYSYMBOL_ConstBit = 839, /* ConstBit */ - YYSYMBOL_BitWithLength = 840, /* BitWithLength */ - YYSYMBOL_BitWithoutLength = 841, /* BitWithoutLength */ - YYSYMBOL_Character = 842, /* Character */ - YYSYMBOL_ConstCharacter = 843, /* ConstCharacter */ - YYSYMBOL_CharacterWithLength = 844, /* CharacterWithLength */ - YYSYMBOL_CharacterWithoutLength = 845, /* CharacterWithoutLength */ - YYSYMBOL_character = 846, /* character */ - YYSYMBOL_opt_varying = 847, /* opt_varying */ - YYSYMBOL_ConstDatetime = 848, /* ConstDatetime */ - YYSYMBOL_ConstInterval = 849, /* ConstInterval */ - YYSYMBOL_opt_timezone = 850, /* opt_timezone */ - YYSYMBOL_year_keyword = 851, /* year_keyword */ - YYSYMBOL_month_keyword = 852, /* month_keyword */ - YYSYMBOL_day_keyword = 853, /* day_keyword */ - YYSYMBOL_hour_keyword = 854, /* hour_keyword */ - YYSYMBOL_minute_keyword = 855, /* minute_keyword */ - YYSYMBOL_second_keyword = 856, /* second_keyword */ - YYSYMBOL_millisecond_keyword = 857, /* millisecond_keyword */ - YYSYMBOL_microsecond_keyword = 858, /* microsecond_keyword */ - YYSYMBOL_week_keyword = 859, /* week_keyword */ - YYSYMBOL_quarter_keyword = 860, /* quarter_keyword */ - YYSYMBOL_decade_keyword = 861, /* decade_keyword */ - YYSYMBOL_century_keyword = 862, /* century_keyword */ - YYSYMBOL_millennium_keyword = 863, /* millennium_keyword */ - YYSYMBOL_opt_interval = 864, /* opt_interval */ - YYSYMBOL_a_expr = 865, /* a_expr */ - YYSYMBOL_b_expr = 866, /* b_expr */ - YYSYMBOL_c_expr = 867, /* c_expr */ - YYSYMBOL_d_expr = 868, /* d_expr */ - YYSYMBOL_indirection_expr_or_a_expr = 869, /* indirection_expr_or_a_expr */ - YYSYMBOL_indirection_expr = 870, /* indirection_expr */ - YYSYMBOL_list_expr = 871, /* list_expr */ - YYSYMBOL_struct_expr = 872, /* struct_expr */ - YYSYMBOL_func_application = 873, /* func_application */ - YYSYMBOL_func_expr = 874, /* func_expr */ - YYSYMBOL_func_expr_windowless = 875, /* func_expr_windowless */ - YYSYMBOL_func_expr_common_subexpr = 876, /* func_expr_common_subexpr */ - YYSYMBOL_list_comprehension = 877, /* list_comprehension */ - YYSYMBOL_within_group_clause = 878, /* within_group_clause */ - YYSYMBOL_filter_clause = 879, /* filter_clause */ - YYSYMBOL_export_clause = 880, /* export_clause */ - YYSYMBOL_window_clause = 881, /* window_clause */ - YYSYMBOL_window_definition_list = 882, /* window_definition_list */ - YYSYMBOL_window_definition = 883, /* window_definition */ - YYSYMBOL_over_clause = 884, /* over_clause */ - YYSYMBOL_window_specification = 885, /* window_specification */ - YYSYMBOL_opt_existing_window_name = 886, /* opt_existing_window_name */ - YYSYMBOL_opt_partition_clause = 887, /* opt_partition_clause */ - YYSYMBOL_opt_frame_clause = 888, /* opt_frame_clause */ - YYSYMBOL_frame_extent = 889, /* frame_extent */ - YYSYMBOL_frame_bound = 890, /* frame_bound */ - YYSYMBOL_opt_window_exclusion_clause = 891, /* opt_window_exclusion_clause */ - YYSYMBOL_qualified_row = 892, /* qualified_row */ - YYSYMBOL_row = 893, /* row */ - YYSYMBOL_dict_arg = 894, /* dict_arg */ - YYSYMBOL_dict_arguments = 895, /* dict_arguments */ - YYSYMBOL_dict_arguments_opt_comma = 896, /* dict_arguments_opt_comma */ - YYSYMBOL_map_arg = 897, /* map_arg */ - YYSYMBOL_map_arguments = 898, /* map_arguments */ - YYSYMBOL_map_arguments_opt_comma = 899, /* map_arguments_opt_comma */ - YYSYMBOL_opt_map_arguments_opt_comma = 900, /* opt_map_arguments_opt_comma */ - YYSYMBOL_sub_type = 901, /* sub_type */ - YYSYMBOL_all_Op = 902, /* all_Op */ - YYSYMBOL_MathOp = 903, /* MathOp */ - YYSYMBOL_qual_Op = 904, /* qual_Op */ - YYSYMBOL_qual_all_Op = 905, /* qual_all_Op */ - YYSYMBOL_subquery_Op = 906, /* subquery_Op */ - YYSYMBOL_any_operator = 907, /* any_operator */ - YYSYMBOL_c_expr_list = 908, /* c_expr_list */ - YYSYMBOL_c_expr_list_opt_comma = 909, /* c_expr_list_opt_comma */ - YYSYMBOL_expr_list = 910, /* expr_list */ - YYSYMBOL_expr_list_opt_comma = 911, /* expr_list_opt_comma */ - YYSYMBOL_opt_expr_list_opt_comma = 912, /* opt_expr_list_opt_comma */ - YYSYMBOL_func_arg_list = 913, /* func_arg_list */ - YYSYMBOL_func_arg_expr = 914, /* func_arg_expr */ - YYSYMBOL_type_list = 915, /* type_list */ - YYSYMBOL_extract_list = 916, /* extract_list */ - YYSYMBOL_extract_arg = 917, /* extract_arg */ - YYSYMBOL_overlay_list = 918, /* overlay_list */ - YYSYMBOL_overlay_placing = 919, /* overlay_placing */ - YYSYMBOL_position_list = 920, /* position_list */ - YYSYMBOL_substr_list = 921, /* substr_list */ - YYSYMBOL_substr_from = 922, /* substr_from */ - YYSYMBOL_substr_for = 923, /* substr_for */ - YYSYMBOL_trim_list = 924, /* trim_list */ - YYSYMBOL_in_expr = 925, /* in_expr */ - YYSYMBOL_case_expr = 926, /* case_expr */ - YYSYMBOL_when_clause_list = 927, /* when_clause_list */ - YYSYMBOL_when_clause = 928, /* when_clause */ - YYSYMBOL_case_default = 929, /* case_default */ - YYSYMBOL_case_arg = 930, /* case_arg */ - YYSYMBOL_columnref = 931, /* columnref */ - YYSYMBOL_opt_slice_bound = 932, /* opt_slice_bound */ - YYSYMBOL_opt_indirection = 933, /* opt_indirection */ - YYSYMBOL_opt_func_arguments = 934, /* opt_func_arguments */ - YYSYMBOL_extended_indirection_el = 935, /* extended_indirection_el */ - YYSYMBOL_opt_extended_indirection = 936, /* opt_extended_indirection */ - YYSYMBOL_opt_asymmetric = 937, /* opt_asymmetric */ - YYSYMBOL_opt_target_list_opt_comma = 938, /* opt_target_list_opt_comma */ - YYSYMBOL_target_list = 939, /* target_list */ - YYSYMBOL_target_list_opt_comma = 940, /* target_list_opt_comma */ - YYSYMBOL_target_el = 941, /* target_el */ - YYSYMBOL_except_list = 942, /* except_list */ - YYSYMBOL_opt_except_list = 943, /* opt_except_list */ - YYSYMBOL_replace_list_el = 944, /* replace_list_el */ - YYSYMBOL_replace_list = 945, /* replace_list */ - YYSYMBOL_replace_list_opt_comma = 946, /* replace_list_opt_comma */ - YYSYMBOL_opt_replace_list = 947, /* opt_replace_list */ - YYSYMBOL_qualified_name_list = 948, /* qualified_name_list */ - YYSYMBOL_name_list = 949, /* name_list */ - YYSYMBOL_name_list_opt_comma = 950, /* name_list_opt_comma */ - YYSYMBOL_name_list_opt_comma_opt_bracket = 951, /* name_list_opt_comma_opt_bracket */ - YYSYMBOL_name = 952, /* name */ - YYSYMBOL_func_name = 953, /* func_name */ - YYSYMBOL_AexprConst = 954, /* AexprConst */ - YYSYMBOL_Iconst = 955, /* Iconst */ - YYSYMBOL_type_function_name = 956, /* type_function_name */ - YYSYMBOL_function_name_token = 957, /* function_name_token */ - YYSYMBOL_type_name_token = 958, /* type_name_token */ - YYSYMBOL_any_name = 959, /* any_name */ - YYSYMBOL_attrs = 960, /* attrs */ - YYSYMBOL_opt_name_list = 961, /* opt_name_list */ - YYSYMBOL_param_name = 962, /* param_name */ - YYSYMBOL_ColLabelOrString = 963, /* ColLabelOrString */ - YYSYMBOL_TransactionStmt = 964, /* TransactionStmt */ - YYSYMBOL_opt_transaction = 965, /* opt_transaction */ - YYSYMBOL_UpdateStmt = 966, /* UpdateStmt */ - YYSYMBOL_UpdateExtensionsStmt = 967, /* UpdateExtensionsStmt */ - YYSYMBOL_UseStmt = 968, /* UseStmt */ - YYSYMBOL_VacuumStmt = 969, /* VacuumStmt */ - YYSYMBOL_vacuum_option_elem = 970, /* vacuum_option_elem */ - YYSYMBOL_opt_full = 971, /* opt_full */ - YYSYMBOL_vacuum_option_list = 972, /* vacuum_option_list */ - YYSYMBOL_opt_freeze = 973, /* opt_freeze */ - YYSYMBOL_VariableResetStmt = 974, /* VariableResetStmt */ - YYSYMBOL_generic_reset = 975, /* generic_reset */ - YYSYMBOL_reset_rest = 976, /* reset_rest */ - YYSYMBOL_VariableSetStmt = 977, /* VariableSetStmt */ - YYSYMBOL_set_rest = 978, /* set_rest */ - YYSYMBOL_generic_set = 979, /* generic_set */ - YYSYMBOL_var_value = 980, /* var_value */ - YYSYMBOL_zone_value = 981, /* zone_value */ - YYSYMBOL_var_list = 982, /* var_list */ - YYSYMBOL_VariableShowStmt = 983, /* VariableShowStmt */ - YYSYMBOL_describe_or_desc = 984, /* describe_or_desc */ - YYSYMBOL_show_or_describe = 985, /* show_or_describe */ - YYSYMBOL_opt_tables = 986, /* opt_tables */ - YYSYMBOL_var_name = 987, /* var_name */ - YYSYMBOL_table_id = 988, /* table_id */ - YYSYMBOL_ViewStmt = 989, /* ViewStmt */ - YYSYMBOL_opt_check_option = 990 /* opt_check_option */ -}; -typedef enum yysymbol_kind_t yysymbol_kind_t; +/* Enabling traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif +/* 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; + PGIgnoreNulls ignorenulls; + PGConstrType constr; + PGLockClauseStrength lockstrength; + PGLockWaitPolicy lockwaitpolicy; + PGSubLinkType subquerytype; + PGViewCheckOption viewcheckoption; + PGInsertColumnOrder bynameorposition; + PGLoadInstallType loadinstalltype; + PGTransactionStmtType transactiontype; +} +/* Line 193 of yacc.c. */ +#line 1330 "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; -#endif +/* Line 216 of yacc.c. */ +#line 1355 "third_party/libpg_query/grammar/grammar_out.cpp" -#ifdef __INT_LEAST16_MAX__ -typedef __INT_LEAST16_TYPE__ yytype_int16; -#elif defined YY_STDINT_H -typedef int_least16_t yytype_int16; -#else -typedef short yytype_int16; +#ifdef short +# undef short #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 +#ifdef YYTYPE_UINT8 +typedef YYTYPE_UINT8 yytype_uint8; +#else +typedef unsigned char yytype_uint8; #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; +#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 @@ -1354,106 +1389,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. */ @@ -1470,11 +1454,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 @@ -1482,8 +1466,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 @@ -1497,120 +1481,113 @@ 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 870 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 73750 +#define YYLAST 73243 /* YYNTOKENS -- Number of terminals. */ #define YYNTOKENS 528 /* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 463 +#define YYNNTS 464 /* YYNRULES -- Number of rules. */ -#define YYNRULES 2132 -/* YYNSTATES -- Number of states. */ -#define YYNSTATES 3538 +#define YYNRULES 2135 +/* YYNRULES -- Number of states. */ +#define YYNSTATES 3549 -/* YYMAXUTOK -- Last valid token kind. */ +/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +#define YYUNDEFTOK 2 #define YYMAXUTOK 760 +#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, @@ -1692,14 +1669,881 @@ 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, 93, 94, 99, 106, + 111, 118, 123, 130, 135, 142, 144, 147, 151, 154, + 156, 160, 163, 167, 169, 173, 176, 182, 186, 193, + 198, 205, 212, 219, 225, 231, 238, 248, 253, 259, + 267, 274, 279, 288, 293, 296, 301, 305, 312, 317, + 320, 323, 326, 329, 331, 334, 335, 337, 340, 343, + 346, 348, 352, 357, 360, 362, 363, 366, 370, 373, + 377, 379, 382, 384, 386, 388, 390, 392, 394, 396, + 399, 402, 404, 406, 408, 410, 412, 419, 426, 435, + 442, 451, 458, 467, 474, 483, 492, 503, 512, 523, + 525, 526, 536, 538, 543, 548, 556, 559, 561, 565, + 568, 571, 572, 577, 581, 582, 584, 585, 588, 592, + 598, 601, 604, 605, 614, 620, 621, 627, 633, 641, + 644, 645, 647, 649, 651, 655, 658, 659, 661, 662, + 664, 668, 670, 674, 676, 679, 681, 685, 688, 695, + 704, 710, 712, 713, 715, 719, 722, 727, 733, 739, + 748, 756, 758, 759, 768, 780, 791, 792, 794, 795, + 797, 799, 800, 803, 808, 812, 822, 835, 837, 841, + 843, 847, 851, 852, 857, 864, 866, 869, 871, 873, + 874, 876, 879, 882, 884, 887, 890, 892, 895, 899, + 902, 905, 908, 911, 915, 919, 923, 925, 929, 931, + 932, 934, 937, 940, 946, 954, 955, 958, 961, 965, + 969, 972, 975, 978, 980, 982, 983, 986, 989, 990, + 993, 1003, 1016, 1028, 1029, 1032, 1034, 1036, 1038, 1040, + 1042, 1044, 1048, 1049, 1051, 1054, 1056, 1058, 1061, 1064, + 1068, 1070, 1072, 1075, 1078, 1080, 1083, 1087, 1093, 1097, + 1100, 1106, 1108, 1110, 1112, 1113, 1119, 1127, 1133, 1136, + 1140, 1142, 1144, 1147, 1150, 1151, 1155, 1160, 1165, 1166, + 1170, 1173, 1174, 1178, 1180, 1182, 1184, 1186, 1188, 1190, + 1192, 1194, 1196, 1198, 1202, 1206, 1208, 1211, 1214, 1217, + 1220, 1223, 1226, 1227, 1231, 1235, 1239, 1240, 1242, 1245, + 1247, 1250, 1253, 1256, 1259, 1263, 1268, 1270, 1274, 1276, + 1278, 1280, 1282, 1286, 1288, 1291, 1292, 1294, 1297, 1298, + 1300, 1304, 1305, 1308, 1309, 1313, 1317, 1319, 1325, 1329, + 1331, 1335, 1337, 1340, 1342, 1347, 1353, 1359, 1366, 1370, + 1378, 1383, 1395, 1397, 1401, 1404, 1407, 1410, 1411, 1415, + 1417, 1419, 1422, 1425, 1428, 1431, 1433, 1434, 1436, 1439, + 1446, 1451, 1458, 1463, 1470, 1479, 1481, 1483, 1485, 1487, + 1490, 1492, 1495, 1497, 1500, 1502, 1504, 1506, 1508, 1512, + 1516, 1520, 1524, 1526, 1529, 1532, 1534, 1538, 1540, 1542, + 1544, 1548, 1550, 1552, 1553, 1555, 1557, 1559, 1568, 1580, + 1591, 1599, 1610, 1620, 1622, 1624, 1627, 1631, 1640, 1652, + 1662, 1670, 1671, 1675, 1679, 1681, 1683, 1687, 1688, 1690, + 1694, 1696, 1697, 1699, 1700, 1702, 1703, 1705, 1709, 1711, + 1713, 1715, 1717, 1721, 1723, 1724, 1727, 1730, 1731, 1734, + 1735, 1737, 1738, 1740, 1742, 1744, 1748, 1752, 1754, 1756, + 1760, 1764, 1768, 1772, 1776, 1780, 1785, 1789, 1792, 1794, + 1796, 1798, 1800, 1804, 1806, 1808, 1812, 1814, 1816, 1820, + 1824, 1828, 1830, 1833, 1838, 1843, 1846, 1850, 1856, 1862, + 1864, 1866, 1870, 1871, 1883, 1895, 1906, 1919, 1921, 1924, + 1930, 1935, 1940, 1945, 1950, 1958, 1964, 1969, 1977, 1984, + 1994, 2004, 2009, 2011, 2013, 2015, 2017, 2019, 2021, 2023, + 2029, 2031, 2033, 2037, 2039, 2042, 2045, 2048, 2052, 2054, + 2058, 2066, 2068, 2071, 2072, 2075, 2076, 2080, 2084, 2089, + 2094, 2099, 2104, 2108, 2111, 2113, 2115, 2116, 2118, 2120, + 2121, 2124, 2126, 2132, 2134, 2135, 2138, 2141, 2142, 2144, + 2145, 2149, 2155, 2157, 2161, 2166, 2170, 2172, 2174, 2175, + 2178, 2181, 2182, 2185, 2188, 2190, 2192, 2194, 2195, 2198, + 2203, 2209, 2214, 2217, 2221, 2224, 2227, 2230, 2233, 2235, + 2238, 2242, 2243, 2245, 2246, 2252, 2254, 2259, 2266, 2269, + 2271, 2272, 2277, 2278, 2280, 2282, 2285, 2288, 2291, 2293, + 2295, 2298, 2301, 2303, 2305, 2307, 2309, 2311, 2313, 2317, + 2321, 2322, 2324, 2328, 2330, 2333, 2335, 2337, 2339, 2341, + 2343, 2346, 2351, 2356, 2362, 2364, 2366, 2369, 2370, 2373, + 2374, 2376, 2380, 2382, 2383, 2385, 2388, 2392, 2395, 2400, + 2403, 2407, 2410, 2411, 2413, 2416, 2417, 2422, 2428, 2430, + 2433, 2436, 2437, 2439, 2443, 2445, 2448, 2452, 2456, 2460, + 2464, 2468, 2472, 2474, 2479, 2489, 2499, 2503, 2504, 2507, + 2510, 2511, 2517, 2521, 2522, 2524, 2526, 2530, 2536, 2540, + 2542, 2545, 2547, 2551, 2557, 2559, 2562, 2566, 2571, 2577, + 2582, 2588, 2593, 2600, 2606, 2611, 2617, 2623, 2629, 2632, + 2637, 2639, 2641, 2642, 2644, 2649, 2655, 2660, 2661, 2664, + 2667, 2670, 2672, 2674, 2676, 2678, 2679, 2684, 2687, 2689, + 2692, 2695, 2700, 2703, 2710, 2713, 2715, 2719, 2724, 2725, + 2728, 2729, 2732, 2733, 2735, 2739, 2743, 2746, 2747, 2750, + 2755, 2757, 2759, 2761, 2762, 2765, 2769, 2775, 2782, 2785, + 2789, 2791, 2797, 2803, 2809, 2813, 2817, 2821, 2826, 2827, + 2829, 2831, 2833, 2835, 2837, 2840, 2845, 2847, 2849, 2851, + 2853, 2856, 2860, 2861, 2863, 2865, 2867, 2869, 2871, 2874, + 2877, 2880, 2883, 2886, 2888, 2892, 2893, 2895, 2897, 2899, + 2901, 2907, 2910, 2912, 2914, 2916, 2918, 2923, 2925, 2928, + 2931, 2933, 2937, 2941, 2944, 2946, 2947, 2953, 2956, 2962, + 2965, 2967, 2971, 2975, 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, 3032, 3034, 3036, 3038, 3040, 3042, 3044, 3046, + 3048, 3050, 3052, 3054, 3058, 3062, 3066, 3070, 3074, 3078, + 3082, 3083, 3085, 3089, 3093, 3099, 3102, 3105, 3109, 3113, + 3117, 3121, 3125, 3129, 3133, 3137, 3141, 3145, 3149, 3153, + 3157, 3161, 3165, 3168, 3171, 3175, 3179, 3182, 3185, 3189, + 3193, 3199, 3204, 3211, 3215, 3221, 3226, 3233, 3238, 3245, + 3251, 3259, 3263, 3266, 3271, 3275, 3278, 3282, 3286, 3290, + 3294, 3299, 3303, 3308, 3312, 3317, 3323, 3330, 3337, 3345, + 3352, 3360, 3367, 3375, 3379, 3384, 3389, 3396, 3398, 3403, + 3407, 3413, 3415, 3419, 3422, 3425, 3429, 3433, 3437, 3441, + 3445, 3449, 3453, 3457, 3461, 3465, 3469, 3473, 3477, 3481, + 3485, 3488, 3491, 3497, 3504, 3511, 3519, 3521, 3524, 3526, + 3528, 3530, 3533, 3536, 3541, 3545, 3547, 3549, 3551, 3553, + 3555, 3560, 3562, 3564, 3566, 3568, 3571, 3576, 3579, 3582, + 3586, 3590, 3594, 3601, 3609, 3619, 3627, 3635, 3641, 3643, + 3645, 3647, 3653, 3660, 3667, 3672, 3677, 3682, 3687, 3694, + 3700, 3706, 3712, 3717, 3724, 3729, 3737, 3747, 3753, 3754, + 3760, 3765, 3766, 3768, 3769, 3772, 3773, 3775, 3779, 3783, + 3786, 3789, 3790, 3797, 3799, 3800, 3804, 3805, 3809, 3813, + 3817, 3818, 3820, 3825, 3828, 3831, 3834, 3837, 3840, 3844, + 3847, 3850, 3854, 3855, 3860, 3864, 3866, 3872, 3876, 3878, + 3882, 3884, 3887, 3891, 3893, 3897, 3899, 3902, 3904, 3905, + 3907, 3909, 3911, 3913, 3915, 3917, 3919, 3921, 3923, 3925, + 3927, 3929, 3931, 3933, 3935, 3937, 3939, 3941, 3943, 3945, + 3950, 3952, 3957, 3959, 3964, 3966, 3969, 3971, 3974, 3976, + 3979, 3981, 3985, 3987, 3991, 3993, 3996, 3998, 4002, 4004, + 4007, 4009, 4010, 4012, 4016, 4018, 4022, 4026, 4028, 4032, + 4036, 4037, 4039, 4041, 4043, 4045, 4047, 4049, 4051, 4053, + 4055, 4057, 4059, 4061, 4063, 4065, 4067, 4072, 4076, 4079, + 4083, 4084, 4088, 4092, 4095, 4098, 4100, 4101, 4104, 4107, + 4111, 4114, 4116, 4118, 4122, 4128, 4130, 4133, 4138, 4141, + 4142, 4144, 4145, 4147, 4150, 4154, 4160, 4168, 4176, 4178, + 4179, 4180, 4183, 4184, 4187, 4191, 4195, 4199, 4205, 4213, + 4221, 4222, 4225, 4227, 4228, 4230, 4231, 4233, 4237, 4239, + 4242, 4246, 4249, 4251, 4256, 4259, 4261, 4262, 4266, 4268, + 4272, 4274, 4277, 4282, 4285, 4286, 4288, 4292, 4294, 4298, + 4300, 4303, 4305, 4309, 4311, 4313, 4316, 4318, 4320, 4323, + 4325, 4327, 4330, 4338, 4341, 4347, 4351, 4355, 4357, 4359, + 4361, 4363, 4365, 4367, 4369, 4371, 4373, 4375, 4377, 4379, + 4381, 4383, 4386, 4389, 4393, 4397, 4398, 4400, 4402, 4404, + 4410, 4414, 4415, 4417, 4419, 4421, 4423, 4425, 4427, 4432, + 4440, 4447, 4450, 4451, 4453, 4455, 4457, 4459, 4473, 4490, + 4492, 4495, 4496, 4498, 4499, 4501, 4502, 4505, 4506, 4508, + 4509, 4516, 4525, 4532, 4541, 4548, 4557, 4561, 4564, 4566, + 4567, 4574, 4581, 4583, 4585, 4587, 4589, 4591, 4593, 4596, + 4598, 4600, 4602, 4604, 4606, 4611, 4618, 4622, 4625, 4630, + 4634, 4640, 4642, 4643, 4645, 4647, 4648, 4650, 4652, 4654, + 4656, 4658, 4660, 4662, 4664, 4666, 4668, 4670, 4672, 4674, + 4676, 4678, 4680, 4682, 4684, 4686, 4688, 4690, 4692, 4694, + 4696, 4698, 4700, 4702, 4704, 4706, 4708, 4710, 4712, 4714, + 4716, 4718, 4720, 4722, 4726, 4728, 4730, 4732, 4734, 4736, + 4738, 4741, 4743, 4745, 4748, 4752, 4756, 4760, 4762, 4766, + 4770, 4773, 4777, 4781, 4783, 4785, 4787, 4791, 4797, 4799, + 4801, 4803, 4805, 4809, 4812, 4817, 4824, 4831, 4832, 4834, + 4836, 4838, 4839, 4842, 4845, 4850, 4857, 4863, 4868, 4875, + 4877, 4879, 4881, 4883, 4885, 4887, 4888, 4890, 4894, 4896, + 4897, 4905, 4909, 4911, 4914, 4918, 4921, 4922, 4925, 4926, + 4929, 4934, 4940, 4949, 4952, 4956, 4962, 4964, 4965, 4968, + 4969, 4972, 4976, 4980, 4984, 4986, 4988, 4990, 4993, 4997, + 5000, 5003, 5006, 5009, 5013, 5018, 5022, 5024, 5026, 5028, + 5030, 5032, 5034, 5035, 5037, 5041, 5043, 5047, 5050, 5060, + 5073, 5085, 5098, 5113, 5117, 5122, 5127, 5128, 5136, 5147, + 5157, 5160, 5164, 5165, 5170, 5172, 5174, 5176, 5178, 5180, + 5182, 5184, 5186, 5188, 5190, 5192, 5194, 5196, 5198, 5200, + 5202, 5204, 5206, 5208, 5210, 5212, 5214, 5216, 5218, 5220, + 5222, 5224, 5226, 5228, 5230, 5232, 5234, 5236, 5238, 5240, + 5242, 5244, 5246, 5248, 5250, 5252, 5254, 5256, 5258, 5260, + 5262, 5264, 5266, 5268, 5270, 5272, 5274, 5276, 5278, 5280, + 5282, 5284, 5286, 5288, 5290, 5292, 5294, 5296, 5298, 5300, + 5302, 5304, 5306, 5308, 5310, 5312, 5314, 5316, 5318, 5320, + 5322, 5324, 5326, 5328, 5330, 5332, 5334, 5336, 5338, 5340, + 5342, 5344, 5346, 5348, 5350, 5352, 5354, 5356, 5358, 5360, + 5362, 5364, 5366, 5368, 5370, 5372, 5374, 5376, 5378, 5380, + 5382, 5384, 5386, 5388, 5390, 5392, 5394, 5396, 5398, 5400, + 5402, 5404, 5406, 5408, 5410, 5412, 5414, 5416, 5418, 5420, + 5422, 5424, 5426, 5428, 5430, 5432, 5434, 5436, 5438, 5440, + 5442, 5444, 5446, 5448, 5450, 5452, 5454, 5456, 5458, 5460, + 5462, 5464, 5466, 5468, 5470, 5472, 5474, 5476, 5478, 5480, + 5482, 5484, 5486, 5488, 5490, 5492, 5494, 5496, 5498, 5500, + 5502, 5504, 5506, 5508, 5510, 5512, 5514, 5516, 5518, 5520, + 5522, 5524, 5526, 5528, 5530, 5532, 5534, 5536, 5538, 5540, + 5542, 5544, 5546, 5548, 5550, 5552, 5554, 5556, 5558, 5560, + 5562, 5564, 5566, 5568, 5570, 5572, 5574, 5576, 5578, 5580, + 5582, 5584, 5586, 5588, 5590, 5592, 5594, 5596, 5598, 5600, + 5602, 5604, 5606, 5608, 5610, 5612, 5614, 5616, 5618, 5620, + 5622, 5624, 5626, 5628, 5630, 5632, 5634, 5636, 5638, 5640, + 5642, 5644, 5646, 5648, 5650, 5652, 5654, 5656, 5658, 5660, + 5662, 5664, 5666, 5668, 5670, 5672, 5674, 5676, 5678, 5680, + 5682, 5684, 5686, 5688, 5690, 5692, 5694, 5696, 5698, 5700, + 5702, 5704, 5706, 5708, 5710, 5712, 5714, 5716, 5718, 5720, + 5722, 5724, 5726, 5728, 5730, 5732, 5734, 5736, 5738, 5740, + 5742, 5744, 5746, 5748, 5750, 5752, 5754, 5756, 5758, 5760, + 5762, 5764, 5766, 5768, 5770, 5772, 5774, 5776, 5778, 5780, + 5782, 5784, 5786, 5788, 5790, 5792, 5794, 5796, 5798, 5800, + 5802, 5804, 5806, 5808, 5810, 5812, 5814, 5816, 5818, 5820, + 5822, 5824, 5826, 5828, 5830, 5832, 5834, 5836, 5838, 5840, + 5842, 5844, 5846, 5848, 5850, 5852, 5854, 5856, 5858, 5860, + 5862, 5864, 5866, 5868, 5870, 5872, 5874, 5876, 5878, 5880, + 5882, 5884, 5886, 5888, 5890, 5892, 5894, 5896, 5898, 5900, + 5902, 5904, 5906, 5908, 5910, 5912, 5914, 5916, 5918, 5920, + 5922, 5924, 5926, 5928, 5930, 5932, 5934, 5936, 5938, 5940, + 5942, 5944, 5946, 5948, 5950, 5952, 5954, 5956, 5958, 5960, + 5962, 5964, 5966, 5968, 5970, 5972, 5974, 5976, 5978, 5980, + 5982, 5984, 5986, 5988, 5990, 5992, 5994, 5996, 5998, 6000, + 6002, 6004, 6006, 6008, 6010, 6012, 6014, 6016, 6018, 6020, + 6022, 6024, 6026, 6028, 6030, 6032, 6034, 6036, 6038, 6040, + 6042, 6044, 6046, 6048, 6050, 6052, 6054, 6056, 6058, 6060, + 6062, 6064, 6066, 6068, 6070, 6072, 6074, 6076, 6078, 6080, + 6082, 6084, 6086, 6088, 6090, 6092, 6094, 6096, 6098, 6100, + 6102, 6104, 6106, 6108, 6110, 6112, 6114, 6116, 6118, 6120, + 6122, 6124, 6126, 6128, 6130, 6132, 6134, 6136, 6138, 6140, + 6142, 6144, 6146, 6148, 6150, 6152, 6154, 6156, 6158, 6160, + 6162, 6164, 6166, 6168, 6170, 6172, 6174, 6176, 6178, 6180, + 6182, 6184, 6186, 6188, 6190, 6192, 6194, 6196, 6198, 6200, + 6202, 6204, 6206, 6208, 6210, 6212, 6214, 6216, 6218, 6220, + 6222, 6224, 6226, 6228, 6230, 6232, 6234, 6236, 6238, 6240, + 6242, 6244, 6246, 6248, 6250, 6252, 6254, 6256, 6258, 6260, + 6262, 6264, 6266, 6268, 6270, 6272, 6274, 6276, 6278, 6280, + 6282, 6284, 6286, 6288, 6290, 6292, 6294, 6296, 6298, 6300, + 6302, 6304, 6306, 6308, 6310, 6312, 6314, 6316, 6318, 6320, + 6322, 6324, 6326, 6328, 6330, 6332, 6334, 6336, 6338, 6340, + 6342, 6344, 6346, 6348, 6350, 6352, 6354, 6356, 6358, 6360, + 6362, 6364, 6366, 6368, 6370, 6372, 6374, 6376, 6378, 6380, + 6382, 6384, 6386, 6388, 6390, 6392, 6394, 6396, 6398, 6400, + 6402, 6404, 6406, 6408, 6410, 6412 +}; + +/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +static const yytype_int16 yyrhs[] = +{ + 529, 0, -1, 530, -1, 530, 520, 531, -1, 531, + -1, 927, -1, 590, -1, 532, -1, 965, -1, 966, + -1, 979, -1, 928, -1, 930, -1, 661, -1, 982, + -1, 657, -1, 917, -1, 581, -1, 579, -1, 603, + -1, 575, -1, 543, -1, 961, -1, 967, -1, 597, + -1, 651, -1, 586, -1, 935, -1, 933, -1, 934, + -1, 920, -1, 554, -1, 952, -1, 578, -1, 914, + -1, 552, -1, 679, -1, 599, -1, 585, -1, 660, + -1, 602, -1, 956, -1, 970, -1, 946, -1, 973, + -1, 980, -1, -1, 32, 419, 766, 540, -1, 32, + 419, 192, 152, 766, 540, -1, 32, 203, 544, 540, + -1, 32, 203, 192, 152, 544, 540, -1, 32, 384, + 544, 540, -1, 32, 384, 192, 152, 544, 540, -1, + 32, 469, 544, 540, -1, 32, 469, 192, 152, 544, + 540, -1, 535, -1, 533, 535, -1, 389, 117, 815, + -1, 137, 117, -1, 359, -1, 359, 592, 593, -1, + 389, 594, -1, 389, 176, 650, -1, 539, -1, 536, + 521, 539, -1, 26, 630, -1, 26, 192, 275, 152, + 630, -1, 26, 82, 630, -1, 26, 82, 192, 275, + 152, 630, -1, 32, 553, 545, 534, -1, 32, 553, + 545, 137, 275, 280, -1, 32, 553, 545, 389, 275, + 280, -1, 32, 553, 545, 389, 405, 596, -1, 32, + 553, 545, 389, 618, -1, 32, 553, 545, 357, 618, + -1, 32, 553, 545, 389, 408, 545, -1, 32, 553, + 545, 26, 176, 650, 40, 191, 606, -1, 32, 553, + 545, 533, -1, 32, 553, 545, 137, 191, -1, 32, + 553, 545, 137, 191, 192, 152, -1, 137, 553, 192, + 152, 545, 655, -1, 137, 553, 545, 655, -1, 32, + 553, 545, 542, 442, 779, 775, 538, -1, 32, 553, + 545, 541, -1, 26, 620, -1, 32, 93, 902, 604, + -1, 460, 93, 902, -1, 137, 93, 192, 152, 902, + 655, -1, 137, 93, 902, 655, -1, 389, 245, -1, + 389, 451, -1, 389, 618, -1, 357, 618, -1, 541, + -1, 457, 815, -1, -1, 614, -1, 389, 614, -1, + 26, 614, -1, 137, 628, -1, 537, -1, 540, 521, + 537, -1, 294, 517, 536, 518, -1, 389, 107, -1, + 389, -1, -1, 111, 902, -1, 111, 326, 902, -1, + 111, 30, -1, 111, 326, 30, -1, 546, -1, 545, + 548, -1, 3, -1, 985, -1, 986, -1, 545, -1, + 5, -1, 5, -1, 549, -1, 548, 549, -1, 519, + 550, -1, 551, -1, 3, -1, 989, -1, 985, -1, + 991, -1, 32, 373, 902, 353, 431, 902, -1, 32, + 419, 766, 353, 431, 902, -1, 32, 419, 192, 152, + 766, 353, 431, 902, -1, 32, 384, 544, 353, 431, + 902, -1, 32, 384, 192, 152, 544, 353, 431, 902, + -1, 32, 469, 544, 353, 431, 902, -1, 32, 469, + 192, 152, 544, 353, 431, 902, -1, 32, 203, 544, + 353, 431, 902, -1, 32, 203, 192, 152, 544, 353, + 431, 902, -1, 32, 419, 766, 353, 553, 902, 431, + 902, -1, 32, 419, 192, 152, 766, 353, 553, 902, + 431, 902, -1, 32, 419, 766, 353, 93, 902, 431, + 902, -1, 32, 419, 192, 152, 766, 353, 93, 902, + 431, 902, -1, 82, -1, -1, 559, 213, 562, 220, + 556, 557, 555, 563, 565, -1, 679, -1, 304, 566, + 462, 679, -1, 517, 570, 518, 679, -1, 517, 570, + 518, 304, 566, 462, 679, -1, 117, 463, -1, 544, + -1, 544, 40, 545, -1, 59, 266, -1, 59, 321, + -1, -1, 517, 573, 518, 772, -1, 290, 93, 902, + -1, -1, 691, -1, -1, 545, 883, -1, 574, 506, + 815, -1, 517, 567, 518, 506, 815, -1, 295, 355, + -1, 295, 193, -1, -1, 290, 91, 558, 133, 454, + 389, 572, 772, -1, 290, 91, 558, 133, 276, -1, + -1, 545, 568, 569, 707, 708, -1, 825, 568, 569, + 707, 708, -1, 517, 815, 518, 568, 569, 707, 708, + -1, 361, 889, -1, -1, 456, -1, 418, -1, 574, + -1, 567, 521, 574, -1, 80, 909, -1, -1, 909, + -1, -1, 560, -1, 570, 521, 560, -1, 561, -1, + 571, 521, 561, -1, 571, -1, 571, 521, -1, 564, + -1, 573, 521, 564, -1, 545, 883, -1, 100, 442, + 544, 40, 144, 680, -1, 100, 442, 544, 40, 144, + 517, 576, 518, -1, 100, 442, 544, 40, 779, -1, + 577, -1, -1, 547, -1, 577, 521, 547, -1, 323, + 545, -1, 323, 545, 506, 951, -1, 323, 545, 517, + 863, 518, -1, 100, 649, 384, 544, 580, -1, 100, + 649, 384, 192, 275, 152, 544, 580, -1, 100, 295, + 355, 649, 384, 544, 580, -1, 591, -1, -1, 100, + 583, 380, 582, 584, 517, 678, 518, -1, 100, 583, + 380, 192, 275, 152, 582, 584, 517, 678, 518, -1, + 100, 295, 355, 583, 380, 582, 584, 517, 678, 518, + -1, -1, 545, -1, -1, 425, -1, 314, -1, -1, + 199, 3, -1, 559, 454, 157, 638, -1, 151, 902, + 589, -1, 100, 649, 419, 984, 40, 151, 902, 589, + 983, -1, 100, 649, 419, 192, 275, 152, 984, 40, + 151, 902, 589, 983, -1, 815, -1, 912, 13, 815, + -1, 587, -1, 588, 521, 587, -1, 517, 588, 518, + -1, -1, 32, 384, 544, 591, -1, 32, 384, 192, + 152, 544, 591, -1, 594, -1, 591, 594, -1, 479, + -1, 503, -1, -1, 4, -1, 508, 4, -1, 509, + 4, -1, 596, -1, 40, 782, -1, 60, 593, -1, + 106, -1, 273, 106, -1, 202, 595, 593, -1, 251, + 593, -1, 261, 593, -1, 273, 251, -1, 273, 261, + -1, 305, 59, 909, -1, 384, 266, 909, -1, 403, + 592, 593, -1, 359, -1, 359, 592, 593, -1, 59, + -1, -1, 905, -1, 508, 905, -1, 509, 905, -1, + 137, 583, 380, 545, 598, -1, 137, 583, 380, 192, + 152, 545, 598, -1, -1, 172, 3, -1, 22, 600, + -1, 52, 600, 601, -1, 403, 600, 601, -1, 86, + 600, -1, 143, 600, -1, 366, 600, -1, 482, -1, + 433, -1, -1, 341, 291, -1, 341, 484, -1, -1, + 455, 544, -1, 100, 649, 419, 544, 517, 636, 518, + 625, 617, -1, 100, 649, 419, 192, 275, 152, 544, + 517, 636, 518, 625, 617, -1, 100, 295, 355, 649, + 419, 544, 517, 636, 518, 625, 617, -1, -1, 604, + 629, -1, 644, -1, 991, -1, 855, -1, 593, -1, + 547, -1, 274, -1, 517, 591, 518, -1, -1, 547, + -1, 273, 25, -1, 360, -1, 63, -1, 389, 280, + -1, 389, 117, -1, 93, 902, 610, -1, 610, -1, + 624, -1, 80, 909, -1, 275, 280, -1, 280, -1, + 448, 635, -1, 329, 227, 635, -1, 74, 517, 815, + 518, 619, -1, 457, 88, 902, -1, 117, 816, -1, + 347, 544, 638, 647, 616, -1, 471, -1, 409, -1, + 611, -1, -1, 176, 650, 40, 191, 606, -1, 176, + 650, 40, 517, 815, 518, 612, -1, 40, 517, 815, + 518, 612, -1, 628, 607, -1, 290, 454, 608, -1, + 615, -1, 640, -1, 615, 640, -1, 640, 615, -1, + -1, 290, 86, 137, -1, 290, 86, 122, 369, -1, + 290, 86, 328, 369, -1, -1, 517, 622, 518, -1, + 273, 205, -1, -1, 93, 902, 645, -1, 645, -1, + 85, -1, 94, -1, 118, -1, 191, -1, 204, -1, + 405, -1, 408, -1, 30, -1, 641, -1, 622, 521, + 641, -1, 457, 203, 632, -1, 119, -1, 275, 119, + -1, 207, 120, -1, 207, 195, -1, 479, 618, -1, + 479, 288, -1, 481, 288, -1, -1, 517, 631, 518, + -1, 627, 201, 621, -1, 627, 149, 621, -1, -1, + 551, -1, 275, 119, -1, 119, -1, 207, 195, -1, + 207, 120, -1, 275, 459, -1, 273, 205, -1, 545, + 779, 639, -1, 545, 778, 613, 639, -1, 634, -1, + 631, 521, 634, -1, 545, -1, 630, -1, 648, -1, + 620, -1, 551, 506, 605, -1, 551, -1, 479, 626, + -1, -1, 646, -1, 646, 521, -1, -1, 545, -1, + 517, 642, 518, -1, -1, 639, 609, -1, -1, 290, + 122, 608, -1, 551, 506, 605, -1, 551, -1, 551, + 519, 551, 506, 605, -1, 551, 519, 551, -1, 637, + -1, 642, 521, 637, -1, 642, -1, 642, 521, -1, + 779, -1, 906, 910, 512, 442, -1, 390, 906, 910, + 512, 442, -1, 74, 517, 815, 518, 604, -1, 448, + 517, 643, 518, 635, 604, -1, 448, 623, 604, -1, + 329, 227, 517, 643, 518, 635, 604, -1, 329, 227, + 623, 604, -1, 169, 227, 517, 643, 518, 347, 544, + 638, 647, 616, 604, -1, 633, -1, 646, 521, 633, + -1, 249, 173, -1, 249, 309, -1, 249, 395, -1, + -1, 237, 544, 627, -1, 425, -1, 423, -1, 241, + 425, -1, 241, 423, -1, 178, 425, -1, 178, 423, + -1, 451, -1, -1, 33, -1, 59, 117, -1, 137, + 652, 192, 152, 654, 655, -1, 137, 652, 654, 655, + -1, 137, 653, 192, 152, 899, 655, -1, 137, 653, + 899, 655, -1, 137, 656, 902, 290, 909, 655, -1, + 137, 656, 192, 152, 902, 290, 909, 655, -1, 419, + -1, 384, -1, 174, -1, 246, -1, 246, 419, -1, + 469, -1, 250, 469, -1, 203, -1, 169, 419, -1, + 81, -1, 97, -1, 373, -1, 405, -1, 426, 377, + 308, -1, 426, 377, 129, -1, 426, 377, 424, -1, + 426, 377, 90, -1, 442, -1, 24, 252, -1, 146, + 436, -1, 156, -1, 169, 107, 483, -1, 335, -1, + 387, -1, 909, -1, 654, 521, 909, -1, 63, -1, + 360, -1, -1, 320, -1, 370, -1, 436, -1, 100, + 649, 658, 544, 659, 40, 419, 679, -1, 100, 649, + 658, 192, 275, 152, 544, 659, 40, 419, 679, -1, + 100, 295, 355, 649, 658, 544, 659, 40, 419, 679, + -1, 100, 649, 658, 544, 659, 40, 815, -1, 100, + 649, 658, 192, 275, 152, 544, 659, 40, 815, -1, + 100, 295, 355, 649, 658, 544, 659, 40, 815, -1, + 174, -1, 246, -1, 517, 518, -1, 517, 863, 518, + -1, 559, 454, 962, 389, 572, 746, 963, 565, -1, + 98, 674, 544, 638, 672, 663, 668, 677, 664, 592, + 669, -1, 98, 517, 679, 518, 431, 668, 677, 592, + 669, -1, 98, 172, 108, 545, 431, 545, 662, -1, + -1, 517, 373, 518, -1, 517, 107, 518, -1, 172, + -1, 431, -1, 666, 124, 547, -1, -1, 676, -1, + 665, 521, 676, -1, 457, -1, -1, 40, -1, -1, + 334, -1, -1, 673, -1, 517, 678, 518, -1, 943, + -1, 593, -1, 821, -1, 510, -1, 517, 665, 518, + -1, 822, -1, -1, 551, 670, -1, 479, 288, -1, + -1, 673, 675, -1, -1, 55, -1, -1, 55, -1, + 288, -1, 171, -1, 123, 667, 547, -1, 280, 667, + 547, -1, 102, -1, 187, -1, 339, 667, 547, -1, + 145, 667, 547, -1, 168, 339, 642, -1, 168, 339, + 510, -1, 310, 59, 642, -1, 310, 59, 510, -1, + 168, 275, 280, 642, -1, 168, 280, 642, -1, 141, + 547, -1, 943, -1, 547, -1, 406, -1, 407, -1, + 3, 519, 545, -1, 3, -1, 671, -1, 678, 521, + 671, -1, 681, -1, 680, -1, 517, 681, 518, -1, + 517, 680, 518, -1, 517, 973, 518, -1, 684, -1, + 682, 704, -1, 682, 703, 737, 710, -1, 682, 703, + 709, 738, -1, 691, 682, -1, 691, 682, 704, -1, + 691, 682, 703, 737, 710, -1, 691, 682, 703, 709, + 738, -1, 684, -1, 680, -1, 382, 701, 888, -1, + -1, 382, 701, 888, 695, 746, 772, 726, 735, 831, + 736, 714, -1, 382, 700, 890, 695, 746, 772, 726, + 735, 831, 736, 714, -1, 172, 747, 683, 695, 772, + 726, 735, 831, 736, 714, -1, 172, 747, 382, 700, + 890, 695, 772, 726, 735, 831, 736, 714, -1, 745, + -1, 419, 766, -1, 682, 447, 698, 699, 682, -1, + 682, 447, 698, 682, -1, 682, 218, 698, 682, -1, + 682, 147, 698, 682, -1, 686, 749, 457, 890, -1, + 686, 749, 457, 890, 181, 59, 901, -1, 686, 749, + 181, 59, 901, -1, 686, 749, 290, 690, -1, 686, + 749, 290, 690, 181, 59, 901, -1, 686, 749, 290, + 690, 457, 890, -1, 686, 749, 290, 690, 457, 890, + 181, 59, 901, -1, 687, 749, 290, 890, 220, 266, + 902, 685, 901, -1, 687, 749, 290, 890, -1, 462, + -1, 463, -1, 315, -1, 317, -1, 452, -1, 316, + -1, 816, -1, 816, 199, 517, 681, 518, -1, 752, + -1, 688, -1, 689, 521, 688, -1, 689, -1, 689, + 521, -1, 479, 692, -1, 503, 692, -1, 479, 345, + 692, -1, 693, -1, 692, 521, 693, -1, 902, 911, + 40, 694, 517, 916, 518, -1, 250, -1, 275, 250, + -1, -1, 220, 696, -1, -1, 425, 697, 544, -1, + 423, 697, 544, -1, 241, 425, 697, 544, -1, 241, + 423, 697, 544, -1, 178, 425, 697, 544, -1, 178, + 423, 697, 544, -1, 451, 697, 544, -1, 419, 544, + -1, 544, -1, 419, -1, -1, 30, -1, 132, -1, + -1, 59, 266, -1, 132, -1, 132, 290, 517, 861, + 518, -1, 30, -1, -1, 193, 282, -1, 358, 282, + -1, -1, 704, -1, -1, 296, 59, 705, -1, 296, + 59, 30, 707, 708, -1, 706, -1, 705, 521, 706, + -1, 815, 457, 855, 708, -1, 815, 707, 708, -1, + 41, -1, 126, -1, -1, 502, 164, -1, 502, 231, + -1, -1, 711, 712, -1, 712, 711, -1, 711, -1, + 712, -1, 709, -1, -1, 238, 720, -1, 238, 720, + 521, 721, -1, 162, 725, 722, 724, 291, -1, 162, + 725, 724, 291, -1, 287, 721, -1, 287, 722, 724, + -1, 4, 512, -1, 9, 512, -1, 4, 313, -1, + 9, 313, -1, 9, -1, 9, 369, -1, 457, 371, + 716, -1, -1, 545, -1, -1, 715, 517, 713, 518, + 719, -1, 713, -1, 713, 517, 545, 518, -1, 713, + 517, 545, 521, 9, 518, -1, 421, 716, -1, 717, + -1, -1, 354, 517, 9, 518, -1, -1, 815, -1, + 30, -1, 815, 512, -1, 4, 313, -1, 9, 313, + -1, 815, -1, 817, -1, 508, 723, -1, 509, 723, + -1, 905, -1, 4, -1, 368, -1, 369, -1, 164, + -1, 272, -1, 181, 59, 728, -1, 181, 59, 30, + -1, -1, 729, -1, 727, 521, 729, -1, 727, -1, + 727, 521, -1, 815, -1, 730, -1, 732, -1, 731, + -1, 733, -1, 517, 518, -1, 367, 517, 861, 518, + -1, 103, 517, 861, 518, -1, 182, 391, 517, 728, + 518, -1, 182, -1, 183, -1, 186, 815, -1, -1, + 336, 815, -1, -1, 739, -1, 167, 341, 291, -1, + 737, -1, -1, 740, -1, 739, 740, -1, 741, 742, + 743, -1, 167, 454, -1, 167, 273, 227, 454, -1, + 167, 392, -1, 167, 227, 392, -1, 285, 898, -1, + -1, 279, -1, 396, 244, -1, -1, 463, 517, 861, + 518, -1, 744, 521, 517, 861, 518, -1, 744, -1, + 744, 521, -1, 172, 748, -1, -1, 749, -1, 747, + 521, 749, -1, 747, -1, 747, 521, -1, 766, 761, + 718, -1, 767, 762, 718, -1, 745, 760, 718, -1, + 232, 767, 762, -1, 680, 761, 718, -1, 232, 680, + 761, -1, 759, -1, 517, 759, 518, 760, -1, 749, + 315, 517, 890, 167, 755, 750, 518, 761, -1, 749, + 452, 751, 517, 756, 167, 758, 518, 761, -1, 181, + 59, 900, -1, -1, 200, 282, -1, 148, 282, -1, + -1, 816, 199, 517, 890, 518, -1, 816, 199, 546, + -1, -1, 818, -1, 820, -1, 517, 859, 518, -1, + 753, 199, 517, 890, 518, -1, 753, 199, 546, -1, + 754, -1, 755, 754, -1, 546, -1, 517, 900, 518, + -1, 756, 199, 517, 890, 518, -1, 757, -1, 758, + 757, -1, 517, 759, 518, -1, 749, 101, 225, 749, + -1, 749, 763, 225, 749, 765, -1, 749, 225, 749, + 765, -1, 749, 269, 763, 225, 749, -1, 749, 269, + 225, 749, -1, 749, 42, 763, 225, 749, 765, -1, + 749, 42, 225, 749, 765, -1, 749, 322, 225, 749, + -1, 749, 37, 225, 749, 765, -1, 749, 383, 225, + 749, 765, -1, 40, 546, 517, 900, 518, -1, 40, + 546, -1, 545, 517, 900, 518, -1, 545, -1, 760, + -1, -1, 760, -1, 40, 517, 773, 518, -1, 40, + 546, 517, 773, 518, -1, 545, 517, 773, 518, -1, + -1, 173, 764, -1, 235, 764, -1, 364, 764, -1, + 383, -1, 37, -1, 209, -1, 300, -1, -1, 457, + 517, 900, 518, -1, 290, 815, -1, 544, -1, 544, + 510, -1, 291, 544, -1, 291, 517, 544, 518, -1, + 825, 771, -1, 369, 172, 517, 769, 518, 771, -1, + 825, 770, -1, 768, -1, 769, 521, 768, -1, 40, + 517, 773, 518, -1, -1, 503, 297, -1, -1, 476, + 815, -1, -1, 774, -1, 773, 521, 774, -1, 546, + 779, 775, -1, 80, 909, -1, -1, 545, 779, -1, + 776, 521, 545, 779, -1, 368, -1, 412, -1, 779, + -1, -1, 782, 781, -1, 390, 782, 781, -1, 782, + 39, 515, 905, 516, -1, 390, 782, 39, 515, 905, + 516, -1, 782, 39, -1, 390, 782, 39, -1, 780, + -1, 777, 517, 776, 518, 781, -1, 247, 517, 865, + 518, 781, -1, 447, 517, 776, 518, 781, -1, 3, + 519, 3, -1, 780, 519, 3, -1, 781, 515, 516, + -1, 781, 515, 905, 516, -1, -1, 784, -1, 786, + -1, 788, -1, 792, -1, 798, -1, 799, 814, -1, + 799, 517, 905, 518, -1, 786, -1, 789, -1, 793, + -1, 798, -1, 908, 785, -1, 517, 862, 518, -1, + -1, 216, -1, 217, -1, 397, -1, 54, -1, 342, + -1, 165, 787, -1, 136, 325, -1, 115, 785, -1, + 112, 785, -1, 283, 785, -1, 57, -1, 517, 905, + 518, -1, -1, 790, -1, 791, -1, 790, -1, 791, + -1, 56, 797, 517, 861, 518, -1, 56, 797, -1, + 794, -1, 795, -1, 794, -1, 795, -1, 796, 517, + 905, 518, -1, 796, -1, 72, 797, -1, 71, 797, + -1, 464, -1, 268, 72, 797, -1, 268, 71, 797, + -1, 270, 797, -1, 466, -1, -1, 430, 517, 905, + 518, 800, -1, 430, 800, -1, 429, 517, 905, 518, + 800, -1, 429, 800, -1, 219, -1, 503, 429, 500, + -1, 481, 429, 500, -1, -1, 497, -1, 498, -1, + 263, -1, 264, -1, 109, -1, 110, -1, 189, -1, + 190, -1, 259, -1, 260, -1, 378, -1, 379, -1, + 257, -1, 258, -1, 253, -1, 254, -1, 473, -1, + 474, -1, 337, -1, 338, -1, 113, -1, 114, -1, + 69, -1, 68, -1, 256, -1, 255, -1, 801, -1, + 802, -1, 803, -1, 804, -1, 805, -1, 806, -1, + 807, -1, 808, -1, 809, -1, 810, -1, 811, -1, + 812, -1, 813, -1, 801, 431, 802, -1, 803, 431, + 804, -1, 803, 431, 805, -1, 803, 431, 806, -1, + 804, 431, 805, -1, 804, 431, 806, -1, 805, 431, + 806, -1, -1, 817, -1, 815, 11, 779, -1, 815, + 80, 909, -1, 815, 46, 429, 500, 815, -1, 508, + 815, -1, 509, 815, -1, 815, 508, 815, -1, 815, + 509, 815, -1, 815, 510, 815, -1, 815, 511, 815, + -1, 815, 15, 815, -1, 815, 512, 815, -1, 815, + 513, 815, -1, 815, 16, 815, -1, 815, 504, 815, + -1, 815, 505, 815, -1, 815, 506, 815, -1, 815, + 19, 815, -1, 815, 20, 815, -1, 815, 21, 815, + -1, 815, 854, 815, -1, 854, 815, -1, 815, 854, + -1, 815, 36, 815, -1, 815, 295, 815, -1, 275, + 815, -1, 501, 815, -1, 815, 177, 815, -1, 815, + 237, 815, -1, 815, 237, 815, 145, 815, -1, 815, + 501, 237, 815, -1, 815, 501, 237, 815, 145, 815, + -1, 815, 194, 815, -1, 815, 194, 815, 145, 815, + -1, 815, 501, 194, 815, -1, 815, 501, 194, 815, + 145, 815, -1, 815, 394, 431, 815, -1, 815, 394, + 431, 815, 145, 815, -1, 815, 501, 394, 431, 815, + -1, 815, 501, 394, 431, 815, 145, 815, -1, 815, + 222, 280, -1, 815, 223, -1, 815, 222, 275, 280, + -1, 815, 275, 280, -1, 815, 278, -1, 815, 17, + 815, -1, 815, 18, 815, -1, 843, 302, 843, -1, + 815, 222, 438, -1, 815, 222, 275, 438, -1, 815, + 222, 160, -1, 815, 222, 275, 160, -1, 815, 222, + 449, -1, 815, 222, 275, 449, -1, 815, 222, 132, + 172, 815, -1, 815, 222, 275, 132, 172, 815, -1, + 815, 222, 285, 517, 865, 518, -1, 815, 222, 275, + 285, 517, 865, 518, -1, 815, 53, 887, 816, 36, + 815, -1, 815, 501, 53, 887, 816, 36, 815, -1, + 815, 53, 416, 816, 36, 815, -1, 815, 501, 53, + 416, 816, 36, 815, -1, 815, 199, 875, -1, 815, + 501, 199, 875, -1, 815, 856, 851, 680, -1, 815, + 856, 851, 517, 815, 518, -1, 117, -1, 83, 517, + 815, 518, -1, 510, 893, 897, -1, 545, 519, 510, + 893, 897, -1, 817, -1, 816, 11, 779, -1, 508, + 816, -1, 509, 816, -1, 816, 508, 816, -1, 816, + 509, 816, -1, 816, 510, 816, -1, 816, 511, 816, + -1, 816, 15, 816, -1, 816, 512, 816, -1, 816, + 513, 816, -1, 816, 16, 816, -1, 816, 504, 816, + -1, 816, 505, 816, -1, 816, 506, 816, -1, 816, + 19, 816, -1, 816, 20, 816, -1, 816, 21, 816, + -1, 816, 854, 816, -1, 854, 816, -1, 816, 854, + -1, 816, 222, 132, 172, 816, -1, 816, 222, 275, + 132, 172, 816, -1, 816, 222, 285, 517, 865, 518, + -1, 816, 222, 275, 285, 517, 865, 518, -1, 818, + -1, 819, 886, -1, 881, -1, 904, -1, 680, -1, + 680, 548, -1, 152, 680, -1, 734, 517, 861, 518, + -1, 517, 815, 518, -1, 820, -1, 843, -1, 522, + -1, 10, -1, 822, -1, 247, 523, 850, 524, -1, + 824, -1, 876, -1, 821, -1, 827, -1, 39, 680, + -1, 39, 515, 862, 516, -1, 525, 9, -1, 526, + 551, -1, 515, 862, 516, -1, 523, 846, 524, -1, + 903, 517, 518, -1, 903, 517, 863, 703, 702, 518, + -1, 903, 517, 465, 864, 703, 702, 518, -1, 903, + 517, 863, 521, 465, 864, 703, 702, 518, -1, 903, + 517, 30, 863, 703, 702, 518, -1, 903, 517, 132, + 863, 703, 702, 518, -1, 823, 828, 829, 830, 834, + -1, 826, -1, 823, -1, 826, -1, 81, 167, 517, + 815, 518, -1, 66, 517, 815, 40, 779, 518, -1, + 441, 517, 815, 40, 779, 518, -1, 159, 517, 866, + 518, -1, 303, 517, 868, 518, -1, 321, 517, 870, + 518, -1, 414, 517, 871, 518, -1, 435, 517, 815, + 40, 779, 518, -1, 437, 517, 58, 874, 518, -1, + 437, 517, 233, 874, 518, -1, 437, 517, 432, 874, + 518, -1, 437, 517, 874, 518, -1, 281, 517, 815, + 521, 815, 518, -1, 79, 517, 861, 518, -1, 515, + 815, 167, 545, 199, 815, 516, -1, 515, 815, 167, + 545, 199, 817, 192, 815, 516, -1, 480, 181, 517, + 704, 518, -1, -1, 163, 517, 476, 815, 518, -1, + 163, 517, 815, 518, -1, -1, 155, -1, -1, 478, + 832, -1, -1, 833, -1, 832, 521, 833, -1, 545, + 40, 835, -1, 301, 835, -1, 301, 545, -1, -1, + 517, 836, 837, 703, 838, 518, -1, 545, -1, -1, + 310, 59, 860, -1, -1, 340, 839, 841, -1, 369, + 839, 841, -1, 184, 839, 841, -1, -1, 840, -1, + 53, 840, 36, 840, -1, 444, 324, -1, 444, 166, + -1, 104, 368, -1, 815, 324, -1, 815, 166, -1, + 148, 104, 368, -1, 148, 181, -1, 148, 428, -1, + 148, 273, 298, -1, -1, 368, 517, 861, 518, -1, + 368, 517, 518, -1, 842, -1, 517, 860, 521, 815, + 518, -1, 546, 527, 815, -1, 844, -1, 845, 521, + 844, -1, 845, -1, 845, 521, -1, 815, 527, 815, + -1, 847, -1, 848, 521, 847, -1, 848, -1, 848, + 521, -1, 849, -1, -1, 38, -1, 399, -1, 30, + -1, 8, -1, 853, -1, 508, -1, 509, -1, 510, + -1, 511, -1, 15, -1, 512, -1, 513, -1, 16, + -1, 504, -1, 505, -1, 506, -1, 19, -1, 20, + -1, 21, -1, 8, -1, 292, 517, 857, 518, -1, + 852, -1, 292, 517, 857, 518, -1, 852, -1, 292, + 517, 857, 518, -1, 237, -1, 501, 237, -1, 177, + -1, 501, 177, -1, 194, -1, 501, 194, -1, 852, + -1, 545, 519, 857, -1, 817, -1, 858, 521, 817, + -1, 858, -1, 858, 521, -1, 815, -1, 860, 521, + 815, -1, 860, -1, 860, 521, -1, 861, -1, -1, + 864, -1, 863, 521, 864, -1, 815, -1, 912, 13, + 815, -1, 912, 14, 815, -1, 779, -1, 865, 521, + 779, -1, 867, 172, 815, -1, -1, 3, -1, 801, + -1, 802, -1, 803, -1, 804, -1, 805, -1, 806, + -1, 807, -1, 808, -1, 809, -1, 810, -1, 811, + -1, 812, -1, 813, -1, 547, -1, 815, 869, 872, + 873, -1, 815, 869, 872, -1, 318, 815, -1, 816, + 199, 816, -1, -1, 815, 872, 873, -1, 815, 873, + 872, -1, 815, 872, -1, 815, 873, -1, 860, -1, + -1, 172, 815, -1, 167, 815, -1, 815, 172, 861, + -1, 172, 861, -1, 861, -1, 680, -1, 517, 861, + 518, -1, 65, 880, 877, 879, 143, -1, 878, -1, + 877, 878, -1, 475, 815, 427, 815, -1, 139, 815, + -1, -1, 815, -1, -1, 545, -1, 545, 548, -1, + 515, 815, 516, -1, 515, 882, 527, 882, 516, -1, + 515, 882, 527, 882, 527, 882, 516, -1, 515, 882, + 527, 509, 527, 882, 516, -1, 815, -1, -1, -1, + 883, 549, -1, -1, 517, 518, -1, 517, 863, 518, + -1, 519, 550, 884, -1, 515, 815, 516, -1, 515, + 882, 527, 882, 516, -1, 515, 882, 527, 882, 527, + 882, 516, -1, 515, 882, 527, 509, 527, 882, 516, + -1, -1, 886, 885, -1, 45, -1, -1, 890, -1, + -1, 891, -1, 889, 521, 891, -1, 889, -1, 889, + 521, -1, 815, 40, 913, -1, 815, 3, -1, 815, + -1, 148, 517, 900, 518, -1, 148, 545, -1, 892, + -1, -1, 815, 40, 545, -1, 894, -1, 895, 521, + 894, -1, 895, -1, 895, 521, -1, 355, 517, 896, + 518, -1, 355, 894, -1, -1, 544, -1, 898, 521, + 544, -1, 902, -1, 899, 521, 902, -1, 899, -1, + 899, 521, -1, 900, -1, 517, 900, 518, -1, 546, + -1, 907, -1, 545, 548, -1, 905, -1, 4, -1, + 547, 883, -1, 6, -1, 7, -1, 903, 547, -1, + 903, 517, 863, 703, 702, 518, 547, -1, 783, 547, + -1, 799, 517, 815, 518, 814, -1, 799, 905, 814, + -1, 799, 547, 814, -1, 438, -1, 160, -1, 280, + -1, 9, -1, 3, -1, 985, -1, 990, -1, 3, + -1, 985, -1, 987, -1, 3, -1, 985, -1, 988, + -1, 545, -1, 545, 910, -1, 519, 550, -1, 910, + 519, 550, -1, 517, 900, 518, -1, -1, 906, -1, + 551, -1, 5, -1, 326, 902, 915, 40, 916, -1, + 517, 865, 518, -1, -1, 679, -1, 554, -1, 660, + -1, 661, -1, 961, -1, 973, -1, 100, 373, 544, + 918, -1, 100, 373, 192, 275, 152, 544, 918, -1, + 100, 295, 355, 373, 544, 918, -1, 918, 919, -1, + -1, 603, -1, 920, -1, 579, -1, 980, -1, 100, + 926, 203, 923, 924, 290, 544, 922, 517, 573, 518, + 925, 772, -1, 100, 926, 203, 923, 192, 275, 152, + 632, 290, 544, 922, 517, 573, 518, 925, 772, -1, + 545, -1, 457, 921, -1, -1, 89, -1, -1, 632, + -1, -1, 479, 618, -1, -1, 448, -1, -1, 32, + 419, 766, 389, 373, 902, -1, 32, 419, 192, 152, + 766, 389, 373, 902, -1, 32, 384, 544, 389, 373, + 902, -1, 32, 384, 192, 152, 544, 389, 373, 902, + -1, 32, 469, 544, 389, 373, 902, -1, 32, 469, + 192, 152, 544, 389, 373, 902, -1, 168, 75, 929, + -1, 75, 929, -1, 545, -1, -1, 84, 290, 932, + 544, 222, 931, -1, 84, 290, 82, 815, 222, 931, + -1, 547, -1, 280, -1, 419, -1, 384, -1, 174, + -1, 246, -1, 246, 419, -1, 469, -1, 108, -1, + 203, -1, 373, -1, 442, -1, 154, 108, 547, 669, + -1, 154, 108, 545, 431, 547, 669, -1, 198, 108, + 547, -1, 153, 938, -1, 153, 942, 936, 938, -1, + 153, 467, 938, -1, 153, 517, 941, 518, 938, -1, + 467, -1, -1, 943, -1, 593, -1, -1, 927, -1, + 590, -1, 532, -1, 979, -1, 928, -1, 661, -1, + 982, -1, 657, -1, 917, -1, 579, -1, 603, -1, + 575, -1, 543, -1, 961, -1, 651, -1, 586, -1, + 920, -1, 554, -1, 952, -1, 578, -1, 914, -1, + 552, -1, 679, -1, 599, -1, 660, -1, 585, -1, + 956, -1, 970, -1, 946, -1, 973, -1, 980, -1, + 3, -1, 985, -1, 989, -1, 939, -1, 547, -1, + 944, -1, 941, 521, 944, -1, 35, -1, 34, -1, + 438, -1, 160, -1, 290, -1, 940, -1, 945, 937, + -1, 939, -1, 942, -1, 389, 947, -1, 389, 241, + 947, -1, 389, 388, 947, -1, 389, 178, 947, -1, + 948, -1, 977, 172, 104, -1, 429, 500, 950, -1, + 373, 547, -1, 977, 431, 951, -1, 977, 506, 951, + -1, 815, -1, 547, -1, 3, -1, 799, 547, 814, + -1, 799, 517, 905, 518, 547, -1, 593, -1, 117, + -1, 241, -1, 949, -1, 951, 521, 949, -1, 240, + 954, -1, 953, 214, 954, 955, -1, 953, 214, 954, + 172, 545, 955, -1, 953, 214, 954, 172, 547, 955, + -1, -1, 168, -1, 547, -1, 545, -1, -1, 468, + 547, -1, 468, 545, -1, 458, 958, 960, 936, -1, + 458, 958, 960, 936, 544, 911, -1, 458, 958, 960, + 936, 965, -1, 458, 517, 959, 518, -1, 458, 517, + 959, 518, 544, 911, -1, 942, -1, 467, -1, 171, + -1, 173, -1, 3, -1, 173, -1, -1, 957, -1, + 959, 521, 957, -1, 171, -1, -1, 559, 122, 172, + 962, 964, 963, 565, -1, 439, 697, 962, -1, 766, + -1, 766, 545, -1, 766, 40, 545, -1, 476, 815, + -1, -1, 457, 748, -1, -1, 942, 936, -1, 942, + 936, 544, 911, -1, 47, 968, 547, 969, 669, -1, + 47, 192, 275, 152, 968, 547, 969, 669, -1, 128, + 551, -1, 128, 108, 551, -1, 128, 108, 192, 152, + 551, -1, 108, -1, -1, 40, 545, -1, -1, 357, + 972, -1, 357, 241, 972, -1, 357, 388, 972, -1, + 357, 178, 972, -1, 977, -1, 30, -1, 971, -1, + 429, 500, -1, 433, 224, 236, -1, 975, 679, -1, + 415, 679, -1, 415, 978, -1, 975, 978, -1, 975, + 429, 500, -1, 975, 433, 224, 236, -1, 975, 30, + 976, -1, 975, -1, 127, -1, 126, -1, 393, -1, + 974, -1, 420, -1, -1, 545, -1, 977, 519, 545, + -1, 545, -1, 978, 519, 545, -1, 61, 823, -1, + 100, 649, 469, 544, 638, 925, 40, 679, 981, -1, + 100, 649, 469, 192, 275, 152, 544, 638, 925, 40, + 679, 981, -1, 100, 295, 355, 649, 469, 544, 638, + 925, 40, 679, 981, -1, 100, 649, 345, 469, 544, + 517, 642, 518, 925, 40, 679, 981, -1, 100, 295, + 355, 649, 345, 469, 544, 517, 642, 518, 925, 40, + 679, 981, -1, 479, 74, 293, -1, 479, 64, 74, + 293, -1, 479, 241, 74, 293, -1, -1, 100, 649, + 419, 984, 40, 679, 983, -1, 100, 649, 419, 192, + 275, 152, 984, 40, 679, 983, -1, 100, 295, 355, + 649, 419, 984, 40, 679, 983, -1, 479, 107, -1, + 479, 273, 107, -1, -1, 544, 638, 625, 617, -1, + 22, -1, 23, -1, 24, -1, 25, -1, 26, -1, + 27, -1, 28, -1, 29, -1, 31, -1, 32, -1, + 33, -1, 43, -1, 44, -1, 46, -1, 47, -1, + 48, -1, 50, -1, 51, -1, 52, -1, 59, -1, + 60, -1, 61, -1, 62, -1, 63, -1, 64, -1, + 67, -1, 68, -1, 69, -1, 70, -1, 73, -1, + 75, -1, 76, -1, 77, -1, 78, -1, 84, -1, + 85, -1, 86, -1, 87, -1, 88, -1, 90, -1, + 91, -1, 92, -1, 94, -1, 95, -1, 96, -1, + 97, -1, 98, -1, 99, -1, 102, -1, 103, -1, + 104, -1, 105, -1, 106, -1, 107, -1, 108, -1, + 109, -1, 110, -1, 111, -1, 113, -1, 114, -1, + 116, -1, 118, -1, 120, -1, 121, -1, 122, -1, + 123, -1, 124, -1, 125, -1, 128, -1, 129, -1, + 130, -1, 131, -1, 134, -1, 135, -1, 136, -1, + 137, -1, 138, -1, 140, -1, 141, -1, 142, -1, + 144, -1, 145, -1, 146, -1, 148, -1, 149, -1, + 150, -1, 151, -1, 153, -1, 154, -1, 155, -1, + 156, -1, 157, -1, 158, -1, 161, -1, 163, -1, + 164, -1, 166, -1, 168, -1, 170, -1, 174, -1, + 175, -1, 178, -1, 180, -1, 184, -1, 185, -1, + 187, -1, 188, -1, 189, -1, 190, -1, 191, -1, + 192, -1, 193, -1, 195, -1, 196, -1, 197, -1, + 198, -1, 200, -1, 201, -1, 202, -1, 203, -1, + 204, -1, 205, -1, 206, -1, 208, -1, 211, -1, + 212, -1, 213, -1, 214, -1, 215, -1, 221, -1, + 224, -1, 226, -1, 227, -1, 228, -1, 229, -1, + 230, -1, 231, -1, 234, -1, 236, -1, 239, -1, + 240, -1, 241, -1, 242, -1, 243, -1, 244, -1, + 245, -1, 246, -1, 248, -1, 249, -1, 250, -1, + 251, -1, 252, -1, 253, -1, 254, -1, 255, -1, + 256, -1, 257, -1, 258, -1, 259, -1, 260, -1, + 261, -1, 262, -1, 263, -1, 264, -1, 265, -1, + 266, -1, 267, -1, 271, -1, 272, -1, 273, -1, + 276, -1, 277, -1, 279, -1, 282, -1, 284, -1, + 285, -1, 286, -1, 288, -1, 289, -1, 292, -1, + 293, -1, 294, -1, 297, -1, 298, -1, 301, -1, + 304, -1, 305, -1, 306, -1, 307, -1, 308, -1, + 309, -1, 310, -1, 311, -1, 312, -1, 313, -1, + 314, -1, 319, -1, 320, -1, 323, -1, 324, -1, + 326, -1, 327, -1, 328, -1, 330, -1, 331, -1, + 332, -1, 333, -1, 334, -1, 335, -1, 337, -1, + 338, -1, 339, -1, 340, -1, 341, -1, 343, -1, + 344, -1, 345, -1, 346, -1, 348, -1, 349, -1, + 350, -1, 351, -1, 352, -1, 353, -1, 354, -1, + 355, -1, 356, -1, 357, -1, 358, -1, 359, -1, + 360, -1, 362, -1, 363, -1, 365, -1, 366, -1, + 367, -1, 369, -1, 370, -1, 371, -1, 372, -1, + 373, -1, 374, -1, 375, -1, 376, -1, 377, -1, + 378, -1, 379, -1, 380, -1, 381, -1, 384, -1, + 385, -1, 386, -1, 387, -1, 388, -1, 389, -1, + 391, -1, 392, -1, 395, -1, 396, -1, 398, -1, + 400, -1, 401, -1, 402, -1, 403, -1, 404, -1, + 405, -1, 406, -1, 407, -1, 408, -1, 409, -1, + 410, -1, 411, -1, 413, -1, 417, -1, 418, -1, + 420, -1, 422, -1, 423, -1, 424, -1, 425, -1, + 426, -1, 428, -1, 433, -1, 434, -1, 436, -1, + 439, -1, 440, -1, 442, -1, 443, -1, 444, -1, + 445, -1, 446, -1, 449, -1, 450, -1, 451, -1, + 453, -1, 454, -1, 455, -1, 456, -1, 458, -1, + 459, -1, 460, -1, 461, -1, 462, -1, 466, -1, + 468, -1, 469, -1, 470, -1, 471, -1, 472, -1, + 473, -1, 474, -1, 477, -1, 480, -1, 481, -1, + 482, -1, 483, -1, 484, -1, 485, -1, 497, -1, + 498, -1, 499, -1, 500, -1, 53, -1, 54, -1, + 56, -1, 57, -1, 71, -1, 72, -1, 79, -1, + 83, -1, 112, -1, 115, -1, 152, -1, 159, -1, + 165, -1, 176, -1, 182, -1, 183, -1, 210, -1, + 216, -1, 217, -1, 219, -1, 247, -1, 268, -1, + 270, -1, 274, -1, 281, -1, 283, -1, 299, -1, + 303, -1, 321, -1, 325, -1, 342, -1, 368, -1, + 390, -1, 397, -1, 412, -1, 414, -1, 429, -1, + 430, -1, 435, -1, 437, -1, 441, -1, 463, -1, + 464, -1, 486, -1, 487, -1, 488, -1, 489, -1, + 490, -1, 491, -1, 492, -1, 493, -1, 494, -1, + 495, -1, 496, -1, 42, -1, 49, -1, 55, -1, + 81, -1, 89, -1, 101, -1, 171, -1, 173, -1, + 176, -1, 177, -1, 194, -1, 209, -1, 222, -1, + 223, -1, 225, -1, 235, -1, 237, -1, 247, -1, + 269, -1, 278, -1, 300, -1, 302, -1, 322, -1, + 364, -1, 394, -1, 412, -1, 421, -1, 467, -1, + 37, -1, 42, -1, 49, -1, 55, -1, 81, -1, + 83, -1, 89, -1, 101, -1, 171, -1, 173, -1, + 177, -1, 194, -1, 209, -1, 222, -1, 223, -1, + 225, -1, 235, -1, 237, -1, 269, -1, 278, -1, + 300, -1, 302, -1, 322, -1, 364, -1, 383, -1, + 394, -1, 421, -1, 441, -1, 467, -1, 37, -1, + 42, -1, 49, -1, 53, -1, 54, -1, 55, -1, + 56, -1, 57, -1, 72, -1, 71, -1, 79, -1, + 81, -1, 83, -1, 89, -1, 101, -1, 112, -1, + 115, -1, 152, -1, 159, -1, 165, -1, 171, -1, + 173, -1, 176, -1, 177, -1, 182, -1, 183, -1, + 194, -1, 209, -1, 210, -1, 217, -1, 219, -1, + 216, -1, 222, -1, 223, -1, 225, -1, 235, -1, + 237, -1, 247, -1, 268, -1, 269, -1, 270, -1, + 274, -1, 278, -1, 281, -1, 283, -1, 300, -1, + 299, -1, 302, -1, 303, -1, 321, -1, 322, -1, + 325, -1, 342, -1, 364, -1, 368, -1, 383, -1, + 390, -1, 394, -1, 397, -1, 412, -1, 414, -1, + 421, -1, 429, -1, 430, -1, 435, -1, 437, -1, + 441, -1, 463, -1, 464, -1, 467, -1, 486, -1, + 487, -1, 488, -1, 489, -1, 490, -1, 491, -1, + 492, -1, 493, -1, 494, -1, 495, -1, 496, -1, + 37, -1, 42, -1, 49, -1, 55, -1, 81, -1, + 83, -1, 89, -1, 101, -1, 171, -1, 173, -1, + 176, -1, 177, -1, 194, -1, 209, -1, 222, -1, + 223, -1, 225, -1, 235, -1, 237, -1, 247, -1, + 269, -1, 278, -1, 300, -1, 302, -1, 322, -1, + 364, -1, 383, -1, 394, -1, 412, -1, 421, -1, + 441, -1, 467, -1, 30, -1, 34, -1, 35, -1, + 36, -1, 38, -1, 39, -1, 40, -1, 41, -1, + 45, -1, 58, -1, 65, -1, 66, -1, 74, -1, + 80, -1, 82, -1, 93, -1, 100, -1, 117, -1, + 119, -1, 126, -1, 127, -1, 132, -1, 133, -1, + 139, -1, 143, -1, 147, -1, 160, -1, 162, -1, + 167, -1, 169, -1, 172, -1, 179, -1, 181, -1, + 186, -1, 199, -1, 207, -1, 218, -1, 220, -1, + 232, -1, 233, -1, 238, -1, 275, -1, 280, -1, + 287, -1, 290, -1, 291, -1, 295, -1, 296, -1, + 315, -1, 316, -1, 317, -1, 318, -1, 329, -1, + 336, -1, 347, -1, 361, -1, 382, -1, 393, -1, + 399, -1, 415, -1, 416, -1, 419, -1, 427, -1, + 431, -1, 432, -1, 438, -1, 447, -1, 448, -1, + 452, -1, 457, -1, 465, -1, 475, -1, 476, -1, + 478, -1, 479, -1 +}; + +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const yytype_uint16 yyrline[] = { - 0, 504, 504, 520, 532, 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, 583, 9, 18, 27, + 0, 506, 506, 522, 534, 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, 585, 9, 18, 27, 36, 45, 54, 63, 72, 85, 87, 93, 94, 99, 103, 107, 118, 126, 130, 139, 148, 157, 166, 175, 184, 192, 200, 209, 218, 227, 236, 253, 262, 271, @@ -1720,133 +2564,133 @@ static const yytype_int16 yyrline[] = 69, 75, 76, 9, 17, 29, 30, 34, 35, 36, 41, 42, 43, 48, 52, 56, 60, 64, 68, 72, 76, 80, 84, 88, 92, 97, 101, 105, 112, 113, - 117, 118, 119, 7, 16, 28, 29, 2, 9, 15, - 21, 28, 35, 45, 46, 47, 2, 7, 21, 36, - 56, 57, 84, 85, 86, 87, 88, 89, 93, 94, - 99, 104, 105, 106, 107, 108, 113, 120, 121, 122, - 139, 146, 153, 163, 173, 185, 193, 202, 220, 221, - 225, 226, 230, 239, 262, 276, 283, 288, 290, 292, - 294, 297, 300, 301, 302, 303, 308, 312, 313, 318, - 325, 330, 331, 332, 333, 334, 335, 336, 337, 343, - 344, 348, 353, 360, 367, 374, 386, 387, 388, 389, - 393, 398, 399, 400, 405, 410, 411, 412, 413, 414, - 415, 420, 440, 469, 470, 474, 478, 479, 480, 484, - 488, 496, 497, 502, 503, 504, 508, 516, 517, 522, - 523, 527, 532, 536, 540, 545, 553, 554, 558, 559, - 563, 564, 570, 581, 594, 608, 622, 636, 650, 673, - 677, 684, 688, 696, 701, 708, 718, 719, 720, 721, - 722, 729, 736, 737, 742, 743, 9, 19, 29, 39, - 49, 59, 73, 74, 75, 76, 77, 78, 79, 80, - 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, - 95, 96, 97, 98, 99, 100, 105, 106, 111, 112, - 113, 118, 119, 120, 8, 20, 33, 46, 58, 70, - 86, 87, 91, 95, 7, 1, 30, 49, 61, 62, - 63, 67, 68, 73, 77, 82, 86, 94, 95, 99, - 100, 105, 106, 110, 111, 116, 117, 118, 119, 120, - 121, 122, 127, 135, 139, 144, 145, 150, 154, 159, - 163, 167, 171, 175, 179, 183, 187, 191, 195, 199, - 203, 207, 211, 215, 219, 227, 232, 233, 234, 235, - 236, 242, 246, 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, 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, 2053, 2056, 2058, 2060, - 2062, 2064, 2066, 2068, 2070, 2072, 2074, 2076, 2078, 2080, - 2082, 2087, 2092, 2098, 2105, 2110, 2116, 2122, 2153, 2155, - 2157, 2165, 2180, 2182, 2184, 2186, 2188, 2190, 2192, 2194, - 2196, 2198, 2200, 2202, 2204, 2206, 2208, 2210, 2213, 2215, - 2217, 2220, 2222, 2224, 2226, 2228, 2233, 2238, 2245, 2250, - 2257, 2262, 2269, 2274, 2282, 2290, 2298, 2306, 2324, 2332, - 2340, 2348, 2356, 2364, 2372, 2376, 2392, 2400, 2408, 2416, - 2424, 2432, 2440, 2444, 2448, 2452, 2456, 2464, 2472, 2480, - 2488, 2508, 2530, 2541, 2548, 2562, 2570, 2578, 2598, 2600, - 2602, 2604, 2606, 2608, 2610, 2612, 2614, 2616, 2618, 2620, - 2622, 2624, 2626, 2628, 2630, 2632, 2634, 2636, 2638, 2640, - 2644, 2648, 2652, 2666, 2667, 2681, 2682, 2683, 2694, 2718, - 2729, 2739, 2743, 2747, 2754, 2758, 2765, 2769, 2786, 2790, - 2792, 2795, 2798, 2809, 2814, 2821, 2827, 2833, 2842, 2846, - 2853, 2861, 2869, 2880, 2900, 2936, 2947, 2948, 2955, 2961, - 2963, 2965, 2969, 2978, 2983, 2990, 3005, 3012, 3016, 3020, - 3024, 3028, 3038, 3047, 3069, 3070, 3074, 3075, 3076, 3080, - 3081, 3088, 3089, 3093, 3094, 3099, 3107, 3109, 3123, 3126, - 3153, 3154, 3157, 3158, 3166, 3174, 3182, 3191, 3201, 3219, - 3265, 3274, 3283, 3292, 3301, 3313, 3314, 3315, 3316, 3317, - 3331, 3332, 3335, 3336, 3340, 3350, 3351, 3355, 3356, 3360, - 3367, 3368, 3373, 3374, 3379, 3380, 3383, 3384, 3385, 3388, - 3389, 3392, 3393, 3394, 3395, 3396, 3397, 3398, 3399, 3400, - 3401, 3402, 3403, 3404, 3405, 3408, 3410, 3415, 3417, 3422, - 3424, 3426, 3428, 3430, 3432, 3434, 3436, 3450, 3452, 3457, - 3461, 3468, 3473, 3479, 3483, 3490, 3495, 3502, 3507, 3515, - 3519, 3525, 3529, 3538, 3549, 3550, 3554, 3558, 3565, 3566, - 3567, 3568, 3569, 3570, 3571, 3572, 3573, 3574, 3575, 3576, - 3577, 3578, 3579, 3589, 3593, 3600, 3607, 3608, 3624, 3628, - 3633, 3637, 3652, 3657, 3661, 3664, 3667, 3668, 3669, 3672, - 3679, 3689, 3703, 3704, 3708, 3719, 3720, 3723, 3724, 3727, - 3731, 3738, 3746, 3754, 3762, 3772, 3773, 3778, 3779, 3783, - 3784, 3785, 3789, 3798, 3806, 3814, 3823, 3838, 3839, 3844, - 3845, 3855, 3856, 3860, 3861, 3865, 3866, 3869, 3885, 3893, - 3903, 3904, 3907, 3908, 3911, 3915, 3916, 3920, 3921, 3924, - 3925, 3926, 3936, 3937, 3941, 3943, 3949, 3950, 3954, 3955, - 3958, 3969, 3972, 3983, 3987, 3991, 4003, 4007, 4016, 4023, - 4061, 4065, 4069, 4073, 4077, 4081, 4085, 4091, 4108, 4109, - 4110, 4113, 4114, 4115, 4118, 4119, 4120, 4123, 4124, 4127, - 4129, 4134, 4135, 4138, 4142, 4143, 7, 18, 19, 23, - 24, 25, 26, 27, 28, 7, 26, 50, 73, 80, - 85, 86, 87, 88, 8, 33, 62, 66, 67, 72, - 73, 78, 79, 83, 84, 89, 90, 7, 16, 25, - 34, 43, 52, 5, 12, 22, 23, 7, 15, 26, - 27, 30, 31, 32, 33, 34, 35, 36, 37, 38, - 39, 7, 19, 33, 9, 16, 26, 33, 44, 45, - 50, 51, 52, 57, 58, 59, 60, 61, 62, 63, - 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, - 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, - 84, 85, 86, 87, 91, 92, 93, 98, 99, 104, - 108, 116, 117, 122, 123, 124, 130, 135, 143, 144, - 10, 16, 22, 28, 38, 39, 47, 58, 70, 78, - 89, 95, 99, 103, 118, 125, 126, 127, 131, 132, - 7, 17, 26, 35, 46, 47, 49, 50, 53, 54, - 55, 8, 22, 36, 48, 56, 70, 71, 72, 73, - 74, 87, 88, 93, 94, 98, 99, 7, 18, 31, - 35, 42, 53, 54, 60, 61, 9, 19, 7, 16, - 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, + 117, 118, 119, 7, 16, 28, 29, 2, 10, 17, + 24, 32, 40, 51, 52, 53, 57, 58, 59, 2, + 7, 21, 36, 56, 57, 84, 85, 86, 87, 88, + 89, 93, 94, 99, 104, 105, 106, 107, 108, 113, + 120, 121, 122, 139, 146, 153, 163, 173, 185, 193, + 202, 220, 221, 225, 226, 230, 239, 262, 276, 283, + 288, 290, 292, 294, 297, 300, 301, 302, 303, 308, + 312, 313, 318, 325, 330, 331, 332, 333, 334, 335, + 336, 337, 343, 344, 348, 353, 360, 367, 374, 386, + 387, 388, 389, 393, 398, 399, 400, 405, 410, 411, + 412, 413, 414, 415, 420, 440, 469, 470, 474, 478, + 479, 480, 484, 488, 496, 497, 502, 503, 504, 508, + 516, 517, 522, 523, 527, 532, 536, 540, 545, 553, + 554, 558, 559, 563, 564, 570, 581, 594, 608, 622, + 636, 650, 673, 677, 684, 688, 696, 701, 708, 718, + 719, 720, 721, 722, 729, 736, 737, 742, 743, 9, + 19, 29, 39, 49, 59, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 95, 96, 97, 98, 99, 100, 105, + 106, 111, 112, 113, 118, 119, 120, 8, 20, 33, + 46, 58, 70, 86, 87, 91, 95, 7, 1, 30, + 49, 61, 62, 63, 67, 68, 73, 77, 82, 86, + 94, 95, 99, 100, 105, 106, 110, 111, 116, 117, + 118, 119, 120, 121, 122, 127, 135, 139, 144, 145, + 150, 154, 159, 163, 167, 171, 175, 179, 183, 187, + 191, 195, 199, 203, 207, 211, 215, 219, 227, 232, + 233, 234, 235, 236, 242, 246, 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, 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, 2053, + 2056, 2058, 2060, 2062, 2064, 2066, 2068, 2070, 2072, 2074, + 2076, 2078, 2080, 2082, 2087, 2092, 2098, 2105, 2110, 2116, + 2122, 2153, 2155, 2157, 2165, 2180, 2182, 2184, 2186, 2188, + 2190, 2192, 2194, 2196, 2198, 2200, 2202, 2204, 2206, 2208, + 2210, 2213, 2215, 2217, 2220, 2222, 2224, 2226, 2228, 2233, + 2238, 2245, 2250, 2257, 2262, 2269, 2274, 2282, 2290, 2298, + 2306, 2324, 2332, 2340, 2348, 2356, 2364, 2372, 2376, 2392, + 2400, 2408, 2416, 2424, 2432, 2440, 2444, 2448, 2452, 2456, + 2464, 2472, 2480, 2488, 2508, 2530, 2541, 2548, 2562, 2570, + 2578, 2598, 2600, 2602, 2604, 2606, 2608, 2610, 2612, 2614, + 2616, 2618, 2620, 2622, 2624, 2626, 2628, 2630, 2632, 2634, + 2636, 2638, 2640, 2644, 2648, 2652, 2666, 2667, 2681, 2682, + 2683, 2694, 2718, 2729, 2739, 2743, 2747, 2754, 2758, 2765, + 2769, 2786, 2790, 2792, 2795, 2798, 2809, 2814, 2821, 2827, + 2833, 2842, 2846, 2853, 2861, 2869, 2880, 2900, 2936, 2947, + 2948, 2955, 2961, 2963, 2965, 2969, 2978, 2983, 2990, 3005, + 3012, 3016, 3020, 3024, 3028, 3038, 3047, 3069, 3070, 3074, + 3075, 3076, 3080, 3081, 3088, 3089, 3093, 3094, 3099, 3107, + 3109, 3123, 3126, 3153, 3154, 3157, 3158, 3166, 3174, 3182, + 3191, 3201, 3219, 3265, 3274, 3283, 3292, 3301, 3313, 3314, + 3315, 3316, 3317, 3331, 3332, 3335, 3336, 3340, 3350, 3351, + 3355, 3356, 3360, 3367, 3368, 3373, 3374, 3379, 3380, 3383, + 3384, 3385, 3388, 3389, 3392, 3393, 3394, 3395, 3396, 3397, + 3398, 3399, 3400, 3401, 3402, 3403, 3404, 3405, 3408, 3410, + 3415, 3417, 3422, 3424, 3426, 3428, 3430, 3432, 3434, 3436, + 3450, 3452, 3457, 3461, 3468, 3473, 3479, 3483, 3490, 3495, + 3502, 3507, 3515, 3519, 3525, 3529, 3538, 3549, 3550, 3554, + 3558, 3565, 3566, 3567, 3568, 3569, 3570, 3571, 3572, 3573, + 3574, 3575, 3576, 3577, 3578, 3579, 3589, 3593, 3600, 3607, + 3608, 3624, 3628, 3633, 3637, 3652, 3657, 3661, 3664, 3667, + 3668, 3669, 3672, 3679, 3689, 3703, 3704, 3708, 3719, 3720, + 3723, 3724, 3727, 3731, 3738, 3746, 3754, 3762, 3772, 3773, + 3778, 3779, 3783, 3784, 3785, 3789, 3798, 3806, 3814, 3823, + 3838, 3839, 3844, 3845, 3855, 3856, 3860, 3861, 3865, 3866, + 3869, 3885, 3893, 3903, 3904, 3907, 3908, 3911, 3915, 3916, + 3920, 3921, 3924, 3925, 3926, 3936, 3937, 3941, 3943, 3949, + 3950, 3954, 3955, 3958, 3969, 3972, 3983, 3987, 3991, 4003, + 4007, 4016, 4023, 4061, 4065, 4069, 4073, 4077, 4081, 4085, + 4091, 4108, 4109, 4110, 4113, 4114, 4115, 4118, 4119, 4120, + 4123, 4124, 4127, 4129, 4134, 4135, 4138, 4142, 4143, 7, + 18, 19, 23, 24, 25, 26, 27, 28, 7, 26, + 50, 73, 80, 85, 86, 87, 88, 8, 33, 62, + 66, 67, 72, 73, 78, 79, 83, 84, 89, 90, + 7, 16, 25, 34, 43, 52, 5, 12, 22, 23, + 7, 15, 26, 27, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 7, 19, 33, 9, 16, 26, + 33, 44, 45, 50, 51, 52, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 91, 92, 93, + 98, 99, 104, 108, 116, 117, 122, 123, 124, 130, + 135, 143, 144, 10, 16, 22, 28, 38, 39, 47, + 58, 70, 78, 89, 95, 99, 103, 118, 125, 126, + 127, 131, 132, 7, 17, 26, 35, 46, 47, 49, + 50, 53, 54, 55, 8, 22, 36, 48, 56, 70, + 71, 72, 73, 74, 87, 88, 93, 94, 98, 99, + 7, 18, 31, 35, 42, 53, 54, 60, 61, 9, + 19, 7, 16, 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, @@ -1878,18 +2722,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, 75, 75, 75, 75, 75, 75, + 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, 76, 76, - 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, + 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, + 75, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, - 76, 76, 76, 76, 76, 76, 77, 77, 77, 77, + 76, 76, 76, 76, 76, 76, 76, 76, 76, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, - 77, 77, 77, 77, 77, 78, 78, 78, 78, 78, + 77, 77, 77, 77, 77, 77, 77, 77, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, @@ -1897,52 +2741,44 @@ 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, 79, 79, 79, 79, + 78, 78, 78, 78, 78, 78, 78, 78, 78, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, - 79, 79, 79, 79, 79, 79, 79, 79, 80, 80, - 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, + 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, + 79, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, - 80, 80, 80 + 80, 80, 80, 80, 80, 80 }; #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", @@ -2009,64 +2845,50 @@ static const char *const yytname[] = "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", - "GeneratedColumnType", "opt_GeneratedColumnType", - "GeneratedConstraintElem", "generic_option_elem", "key_update", - "key_actions", "OnCommitOption", "reloptions", "opt_no_inherit", - "TableConstraint", "TableLikeOption", "reloption_list", "ExistingIndex", - "ConstraintAttr", "OptWith", "definition", "TableLikeOptionList", - "generic_option_name", "ConstraintAttributeElem", "columnDef", - "def_list", "index_name", "TableElement", "def_elem", "opt_definition", - "OptTableElementList", "columnElem", "opt_column_list", "ColQualList", - "key_delete", "reloption_elem", "columnList", "columnList_opt_comma", - "func_type", "ConstraintElem", "TableElementList", "key_match", - "TableLikeClause", "OptTemp", "generated_when", "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", "opt_force", "file_name", - "opt_ext_version", "PragmaStmt", "PrepareStmt", "prep_type_clause", - "PreparableStmt", "RenameStmt", "opt_column", "SelectStmt", - "select_with_parens", "select_no_parens", "select_clause", "opt_select", - "simple_select", "value_or_values", "pivot_keyword", "unpivot_keyword", + "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", + "UpdateExtensionsStmt", "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", "opt_transaction_type", "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", "TableConstraint", "TableLikeOption", + "reloption_list", "ExistingIndex", "ConstraintAttr", "OptWith", + "definition", "TableLikeOptionList", "generic_option_name", + "ConstraintAttributeElem", "columnDef", "def_list", "index_name", + "TableElement", "def_elem", "opt_definition", "OptTableElementList", + "columnElem", "opt_column_list", "ColQualList", "key_delete", + "reloption_elem", "columnList", "columnList_opt_comma", "func_type", + "ConstraintElem", "TableElementList", "key_match", "TableLikeClause", + "OptTemp", "generated_when", "DropStmt", "drop_type_any_name", + "drop_type_name", "any_name_list", "opt_drop_behavior", + "drop_type_name_on_any_name", "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", "with_clause", "cte_list", "common_table_expr", "opt_materialized", "into_clause", "OptTempTableName", "opt_table", "all_or_distinct", @@ -2130,4741 +2952,4330 @@ 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", - "UpdateExtensionsStmt", "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", "opt_force", + "file_name", "opt_ext_version", "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 (-3116) - -#define yypact_value_is_default(Yyn) \ - ((Yyn) == YYPACT_NINF) - -#define YYTABLE_NINF (-2058) +# 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, 756, 757, 758, 60, 62, 61, 759, 43, 45, + 42, 47, 37, 94, 760, 91, 93, 40, 41, 46, + 59, 44, 63, 123, 125, 35, 36, 58 +}; +# endif -#define yytable_value_is_error(Yyn) \ - ((Yyn) == YYTABLE_NINF) +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const yytype_uint16 yyr1[] = +{ + 0, 528, 529, 530, 530, 531, 531, 531, 531, 531, + 531, 531, 531, 531, 531, 531, 531, 531, 531, 531, + 531, 531, 531, 531, 531, 531, 531, 531, 531, 531, + 531, 531, 531, 531, 531, 531, 531, 531, 531, 531, + 531, 531, 531, 531, 531, 531, 531, 532, 532, 532, + 532, 532, 532, 532, 532, 533, 533, 534, 534, 535, + 535, 535, 535, 536, 536, 537, 537, 537, 537, 537, + 537, 537, 537, 537, 537, 537, 537, 537, 537, 537, + 537, 537, 537, 537, 537, 537, 537, 537, 537, 537, + 537, 537, 537, 537, 538, 538, 539, 539, 539, 539, + 540, 540, 541, 542, 542, 542, 543, 543, 543, 543, + 544, 544, 545, 545, 545, 546, 546, 547, 548, 548, + 549, 550, 551, 551, 551, 551, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 553, + 553, 554, 555, 555, 555, 555, 555, 556, 556, 557, + 557, 557, 558, 558, 558, 559, 559, 560, 561, 561, + 562, 562, 562, 563, 563, 563, 564, 564, 564, 565, + 565, 566, 566, 567, 567, 568, 568, 569, 569, 570, + 570, 571, 571, 572, 572, 573, 573, 574, 575, 575, + 575, 576, 576, 577, 577, 578, 578, 578, 579, 579, + 579, 580, 580, 581, 581, 581, 582, 582, 583, 583, + 583, 584, 584, 585, 586, 586, 586, 587, 587, 588, + 588, 589, 589, 590, 590, 591, 591, 592, 592, 592, + 593, 593, 593, 593, 594, 594, 594, 594, 594, 594, + 594, 594, 594, 594, 594, 594, 594, 594, 595, 595, + 596, 596, 596, 597, 597, 598, 598, 599, 599, 599, + 599, 599, 599, 600, 600, 600, 601, 601, 601, 602, + 603, 603, 603, 604, 604, 605, 605, 605, 605, 605, + 605, 606, 606, 607, 608, 608, 608, 608, 608, 609, + 609, 609, 609, 610, 610, 610, 610, 610, 610, 610, + 610, 611, 611, 612, 612, 613, 613, 613, 614, 615, + 616, 616, 616, 616, 616, 617, 617, 617, 617, 618, + 619, 619, 620, 620, 621, 621, 621, 621, 621, 621, + 621, 621, 622, 622, 623, 624, 624, 624, 624, 625, + 625, 625, 625, 626, 627, 627, 627, 628, 629, 629, + 629, 629, 629, 629, 630, 630, 631, 631, 632, 633, + 633, 633, 634, 634, 635, 635, 636, 636, 636, 637, + 638, 638, 639, 639, 640, 641, 641, 641, 641, 642, + 642, 643, 643, 644, 644, 644, 645, 645, 645, 645, + 645, 645, 646, 646, 647, 647, 647, 647, 648, 649, + 649, 649, 649, 649, 649, 649, 649, 650, 650, 651, + 651, 651, 651, 651, 651, 652, 652, 652, 652, 652, + 652, 652, 652, 652, 652, 652, 652, 652, 652, 652, + 652, 652, 652, 653, 653, 653, 653, 653, 653, 654, + 654, 655, 655, 655, 656, 656, 656, 657, 657, 657, + 657, 657, 657, 658, 658, 659, 659, 660, 661, 661, + 661, 662, 662, 662, 663, 663, 664, 664, 665, 665, + 666, 666, 667, 667, 668, 668, 669, 669, 670, 670, + 670, 670, 670, 670, 670, 671, 672, 672, 673, 673, + 674, 674, 675, 675, 675, 675, 675, 675, 675, 675, + 675, 675, 675, 675, 675, 675, 675, 675, 676, 677, + 677, 677, 677, 677, 678, 678, 679, 679, 680, 680, + 680, 681, 681, 681, 681, 681, 681, 681, 681, 682, + 682, 683, 683, 684, 684, 684, 684, 684, 684, 684, + 684, 684, 684, 684, 684, 684, 684, 684, 684, 684, + 684, 684, 685, 685, 686, 686, 687, 687, 688, 688, + 688, 689, 689, 690, 690, 691, 691, 691, 692, 692, + 693, 694, 694, 694, 695, 695, 696, 696, 696, 696, + 696, 696, 696, 696, 696, 697, 697, 698, 698, 698, + 699, 700, 700, 701, 701, 702, 702, 702, 703, 703, + 704, 704, 705, 705, 706, 706, 707, 707, 707, 708, + 708, 708, 709, 709, 709, 709, 710, 710, 711, 711, + 711, 711, 712, 712, 713, 713, 713, 713, 713, 713, + 714, 714, 715, 715, 716, 716, 716, 716, 717, 718, + 718, 719, 719, 720, 720, 720, 720, 720, 721, 722, + 722, 722, 723, 723, 724, 724, 725, 725, 726, 726, + 726, 727, 727, 728, 728, 729, 729, 729, 729, 729, + 730, 731, 732, 733, 734, 734, 735, 735, 736, 736, + 737, 737, 738, 738, 739, 739, 740, 741, 741, 741, + 741, 742, 742, 743, 743, 743, 744, 744, 745, 745, + 746, 746, 747, 747, 748, 748, 749, 749, 749, 749, + 749, 749, 749, 749, 749, 749, 750, 750, 751, 751, + 751, 752, 752, 753, 753, 753, 753, 754, 754, 755, + 755, 756, 756, 757, 758, 758, 759, 759, 759, 759, + 759, 759, 759, 759, 759, 759, 759, 760, 760, 760, + 760, 761, 761, 762, 762, 762, 762, 762, 763, 763, + 763, 763, 763, 763, 764, 764, 765, 765, 766, 766, + 766, 766, 767, 767, 768, 769, 769, 770, 770, 771, + 771, 772, 772, 773, 773, 774, 775, 775, 776, 776, + 777, 777, 778, 778, 779, 779, 779, 779, 779, 779, + 779, 779, 779, 779, 780, 780, 781, 781, 781, 782, + 782, 782, 782, 782, 782, 782, 783, 783, 783, 783, + 784, 785, 785, 786, 786, 786, 786, 786, 786, 786, + 786, 786, 786, 786, 787, 787, 788, 788, 789, 789, + 790, 791, 792, 792, 793, 793, 794, 795, 796, 796, + 796, 796, 796, 796, 797, 797, 798, 798, 798, 798, + 799, 800, 800, 800, 801, 801, 802, 802, 803, 803, + 804, 804, 805, 805, 806, 806, 807, 807, 808, 808, + 809, 809, 810, 810, 811, 811, 812, 812, 813, 813, + 814, 814, 814, 814, 814, 814, 814, 814, 814, 814, + 814, 814, 814, 814, 814, 814, 814, 814, 814, 814, + 814, 815, 815, 815, 815, 815, 815, 815, 815, 815, + 815, 815, 815, 815, 815, 815, 815, 815, 815, 815, + 815, 815, 815, 815, 815, 815, 815, 815, 815, 815, + 815, 815, 815, 815, 815, 815, 815, 815, 815, 815, + 815, 815, 815, 815, 815, 815, 815, 815, 815, 815, + 815, 815, 815, 815, 815, 815, 815, 815, 815, 815, + 815, 815, 815, 815, 815, 815, 815, 815, 815, 815, + 815, 816, 816, 816, 816, 816, 816, 816, 816, 816, + 816, 816, 816, 816, 816, 816, 816, 816, 816, 816, + 816, 816, 816, 816, 816, 816, 817, 817, 818, 818, + 818, 818, 818, 818, 819, 819, 819, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 821, + 822, 823, 823, 823, 823, 823, 823, 824, 824, 825, + 825, 826, 826, 826, 826, 826, 826, 826, 826, 826, + 826, 826, 826, 826, 826, 827, 827, 828, 828, 829, + 829, 829, 830, 830, 831, 831, 832, 832, 833, 834, + 834, 834, 835, 836, 836, 837, 837, 838, 838, 838, + 838, 839, 839, 840, 840, 840, 840, 840, 841, 841, + 841, 841, 841, 842, 842, 843, 843, 844, 845, 845, + 846, 846, 847, 848, 848, 849, 849, 850, 850, 851, + 851, 851, 852, 852, 853, 853, 853, 853, 853, 853, + 853, 853, 853, 853, 853, 853, 853, 853, 854, 854, + 855, 855, 856, 856, 856, 856, 856, 856, 856, 856, + 857, 857, 858, 858, 859, 859, 860, 860, 861, 861, + 862, 862, 863, 863, 864, 864, 864, 865, 865, 866, + 866, 867, 867, 867, 867, 867, 867, 867, 867, 867, + 867, 867, 867, 867, 867, 867, 868, 868, 869, 870, + 870, 871, 871, 871, 871, 871, 871, 872, 873, 874, + 874, 874, 875, 875, 876, 877, 877, 878, 879, 879, + 880, 880, 881, 881, 549, 549, 549, 549, 882, 882, + 883, 883, 884, 884, 884, 885, 885, 885, 885, 885, + 886, 886, 887, 887, 888, 888, 889, 889, 890, 890, + 891, 891, 891, 892, 892, 893, 893, 894, 895, 895, + 896, 896, 897, 897, 897, 898, 898, 899, 899, 900, + 900, 901, 901, 902, 903, 903, 904, 904, 904, 904, + 904, 904, 904, 904, 904, 904, 904, 904, 904, 904, + 905, 906, 906, 906, 907, 907, 907, 908, 908, 908, + 909, 909, 910, 910, 911, 911, 912, 913, 913, 914, + 915, 915, 916, 916, 916, 916, 916, 916, 917, 917, + 917, 918, 918, 919, 919, 919, 919, 920, 920, 921, + 922, 922, 923, 923, 924, 924, 925, 925, 926, 926, + 927, 927, 927, 927, 927, 927, 928, 928, 929, 929, + 930, 930, 931, 931, 932, 932, 932, 932, 932, 932, + 932, 932, 932, 932, 933, 933, 934, 935, 935, 935, + 935, 936, 936, 937, 937, 937, 938, 938, 938, 938, + 938, 938, 938, 938, 938, 938, 938, 938, 938, 938, + 938, 938, 938, 938, 938, 938, 938, 938, 938, 938, + 938, 938, 938, 938, 938, 938, 938, 939, 939, 939, + 940, 940, 941, 941, 942, 942, 943, 943, 943, 943, + 944, 945, 945, 946, 946, 946, 946, 947, 947, 947, + 947, 948, 948, 949, 950, 950, 950, 950, 950, 950, + 950, 951, 951, 952, 952, 952, 952, 953, 953, 954, + 954, 955, 955, 955, 956, 956, 956, 956, 956, 957, + 957, 957, 957, 957, 958, 958, 959, 959, 960, 960, + 961, 961, 962, 962, 962, 963, 963, 964, 964, 965, + 965, 966, 966, 967, 967, 967, 968, 968, 969, 969, + 970, 970, 970, 970, 971, 971, 972, 972, 972, 973, + 973, 973, 973, 973, 973, 973, 973, 974, 974, 975, + 975, 976, 976, 977, 977, 978, 978, 979, 980, 980, + 980, 980, 980, 981, 981, 981, 981, 982, 982, 982, + 983, 983, 983, 984, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 985, 985, 985, 986, 986, 986, + 986, 986, 986, 986, 986, 986, 986, 986, 986, 986, + 986, 986, 986, 986, 986, 986, 986, 986, 986, 986, + 986, 986, 986, 986, 986, 986, 986, 986, 986, 986, + 986, 986, 986, 986, 986, 986, 986, 986, 986, 986, + 986, 986, 986, 986, 986, 986, 986, 986, 986, 986, + 986, 987, 987, 987, 987, 987, 987, 987, 987, 987, + 987, 987, 987, 987, 987, 987, 987, 987, 987, 987, + 987, 987, 987, 987, 987, 987, 987, 987, 987, 988, + 988, 988, 988, 988, 988, 988, 988, 988, 988, 988, + 988, 988, 988, 988, 988, 988, 988, 988, 988, 988, + 988, 988, 988, 988, 988, 988, 988, 988, 989, 989, + 989, 989, 989, 989, 989, 989, 989, 989, 989, 989, + 989, 989, 989, 989, 989, 989, 989, 989, 989, 989, + 989, 989, 989, 989, 989, 989, 989, 989, 989, 989, + 989, 989, 989, 989, 989, 989, 989, 989, 989, 989, + 989, 989, 989, 989, 989, 989, 989, 989, 989, 989, + 989, 989, 989, 989, 989, 989, 989, 989, 989, 989, + 989, 989, 989, 989, 989, 989, 989, 989, 989, 989, + 989, 989, 989, 989, 989, 989, 989, 989, 989, 990, + 990, 990, 990, 990, 990, 990, 990, 990, 990, 990, + 990, 990, 990, 990, 990, 990, 990, 990, 990, 990, + 990, 990, 990, 990, 990, 990, 990, 990, 990, 990, + 990, 991, 991, 991, 991, 991, 991, 991, 991, 991, + 991, 991, 991, 991, 991, 991, 991, 991, 991, 991, + 991, 991, 991, 991, 991, 991, 991, 991, 991, 991, + 991, 991, 991, 991, 991, 991, 991, 991, 991, 991, + 991, 991, 991, 991, 991, 991, 991, 991, 991, 991, + 991, 991, 991, 991, 991, 991, 991, 991, 991, 991, + 991, 991, 991, 991, 991, 991, 991, 991, 991, 991, + 991, 991, 991, 991, 991, 991 +}; -/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing - STATE-NUM. */ -static const int yypact[] = +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const yytype_uint8 yyr2[] = { - 6260, -36, 142, -3116, -3116, 274, -36, 50411, 65834, 268, - -36, 130, 4307, 52403, -3116, -3116, 46925, 8772, -36, 55889, - 73215, 294, 565, 32270, 680, 56387, -3116, -3116, -3116, 65834, - 55889, 56885, -36, 366, 66332, -3116, -36, 34760, 52901, 449, - -3116, 55889, 89, 385, 57383, 55889, 1805, 911, 420, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, 483, -3116, -3116, -3116, -3116, 150, -3116, - 750, -3116, -3116, -3116, -3116, 160, -3116, 137, 177, 32270, - 32270, 881, 504, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, 34262, -3116, -3116, -3116, -3116, 57881, 55889, - 58379, 53399, 58877, -3116, 763, 1043, -3116, 195, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - 200, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, 585, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, 202, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -101, 211, -3116, -3116, -3116, 613, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, 1992, -3116, -3116, 1034, 4038, 55889, - 382, 731, 820, -3116, 59375, -3116, 801, 55889, -3116, -3116, - 924, 806, 990, -3116, -3116, 53897, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, 47423, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, 972, -3116, -3116, 803, -3116, 112, -3116, -3116, 829, - 792, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - 894, -3116, -3116, -3116, 901, 66830, 59873, 60371, -3116, 788, - 2069, 8111, 73233, 31272, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, 483, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, 56387, 65834, 810, - 817, 1146, 831, 32768, 835, 35259, 848, 854, 1203, 865, - 869, 875, 882, 385, 31771, 906, -101, -3116, 60869, 60869, - -52, 3771, -3116, 60869, 61367, -3116, 917, -3116, 1043, -3116, - -3116, -3116, -3116, 334, 887, -3116, 61865, 61865, 61865, 928, - 1216, -3116, -3116, -3116, 931, -3116, -3116, 1152, 20881, 20881, - 67328, 67328, 1043, 67328, 962, -3116, -3116, 61, -3116, -3116, - -3116, 881, 979, -101, -3116, -3116, 52901, -3116, -3116, 297, - 1345, 20881, 55889, 1002, -3116, 1010, 1002, 1022, 1047, 1059, - -3116, 6260, -3116, 55889, 1359, 1257, 54395, 56387, 661, 661, - 1523, 661, 857, 1169, 2616, 2052, -3116, 1437, -3116, 1069, - 1171, 1103, 1403, -3116, 979, 1496, 1232, 1313, 1519, 5283, - 1529, 1669, 1535, 1697, 1537, 1656, 20881, 47921, -101, -3116, - 11973, 20881, -3116, -3116, -3116, 1272, -3116, -3116, -3116, -3116, - -3116, 55889, 65834, 1181, 1187, -3116, -3116, -3116, -3116, 1619, - 1432, -3116, 1679, -3116, -3116, 1241, 62363, 62861, 63359, 63857, - 67826, 1632, -3116, -3116, 1588, -3116, -3116, -3116, 1269, -3116, - -3116, -3116, 189, 68324, 1594, 1235, 111, -3116, 1607, 125, - -3116, 1612, 1479, 15641, -3116, 1431, -3116, -3116, -3116, 385, - -3116, -3116, -3116, 169, -3116, -3116, 43856, 73233, 1344, 1273, - -3116, 20881, 20881, 1277, 7311, 60869, 61367, 20881, 55889, -3116, - 20881, 25597, 1281, 20881, 20881, 13021, 20881, 30276, 60869, 3771, - 1289, -3116, 377, 55889, 1302, -3116, 1409, 1409, 366, 32270, - 1611, -3116, 284, 1608, 1532, -3116, 32270, 1532, 1019, 1320, - 1613, 1532, -3116, 241, 1616, 1409, 35757, 1325, -3116, 1409, - 1546, -3116, -3116, 20881, 15641, 70814, 1804, -3116, -3116, -3116, - -3116, 1614, 65834, 1330, -3116, -3116, -3116, -3116, -3116, -3116, - 691, 1843, 158, 1849, 20881, 158, 158, 1332, 219, 219, - -3116, 1526, 1339, -3116, 220, 1342, 1350, 1856, 1864, 182, - 154, 1285, 158, 20881, -3116, 219, 1355, 1868, 1357, 1870, - 179, 181, -3116, 221, 20881, 20881, 20881, 1730, 20881, 10925, - -3116, 55889, 1871, 47921, 610, -3116, -101, 1362, 1043, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, 1364, -3116, 187, 5427, - -3116, -3116, -3116, -3116, -3116, -3116, 1402, -3116, -3116, -3116, - -3116, 1583, 20881, -3116, -3116, 1365, 1611, -3116, 222, -3116, - -3116, 1611, -3116, -3116, -3116, -3116, -3116, 260, 1784, 20881, - 20881, 65834, -101, -3116, 68822, -3116, -3116, -3116, -3116, -3116, - -3116, 344, -3116, 483, 45512, 1369, 1375, 1002, 55889, 55889, - 1857, -3116, -3116, -3116, -3116, 1010, 52901, 167, 1676, 146, - 1509, 131, -3116, -3116, 881, 881, 16165, 719, 235, 560, - 16689, 21405, 1740, 1631, 619, 721, 1752, -3116, 1635, 1862, - 25597, 20881, 20881, 857, 1169, 20881, -3116, -3116, -3116, 1686, - 55889, 50909, 703, 849, 1408, 1495, 1411, 275, 1842, -3116, - 1417, -3116, 1510, 55889, 72761, 240, -3116, 1883, 240, 240, - 251, 1884, 1513, 262, 1681, 65, -84, 907, -3116, 1417, - 52901, 148, 88, 1417, 55889, 1514, 404, 1417, 1838, 65834, - 1273, 41389, 1421, -3116, -3116, -3116, 185, 15641, -3116, 639, - 823, 987, 809, 208, 1422, 1444, 15641, 1464, 1508, 197, - 1543, 1558, 1603, 1633, 1645, 1647, 1651, 1655, 153, 1664, - 1670, 1672, 1680, 1699, 1701, -3116, 1712, 199, 1729, 225, - 15641, 1743, -3116, 201, -3116, 45512, 12, -3116, -3116, 1754, - 45641, -3116, 1727, 1520, 1521, 65834, 1474, 55889, 932, 1574, - 1803, 1858, 71297, 55889, 1682, 907, 1687, 1447, 1927, 1696, - 1187, 1700, 1466, 1709, -3116, 1786, -3116, 69320, 47921, -3116, - -3116, -3116, -3116, -3116, 1834, 1818, 65834, 47921, 1475, -3116, - -3116, 65834, -3116, 55889, 55889, -3116, 55889, 65834, -3116, 542, - 45512, 1983, 1249, 73233, 49415, -3116, -3116, -3116, -3116, 528, - 1013, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - 1043, 47921, -3116, 1219, 44429, 1480, 20881, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, 1482, 1836, - -3116, -3116, 5967, 1488, 44478, 1492, 25597, 25597, -101, 2128, - -3116, -3116, 25597, 1493, 49913, 44351, 1494, 1498, 44771, 17213, - 20881, 17213, 17213, 44900, -3116, 1501, 44995, 60869, 1497, 55889, - 54893, -3116, -3116, -3116, 20881, 20881, 3771, 55391, 1544, -3116, - 32270, -3116, 1788, 32270, -3116, -3116, 3313, -3116, 32270, 1796, - 20881, 32270, -3116, 1741, 1742, 1511, 32270, -3116, 55889, 1512, - 55889, -3116, -3116, 45512, -3116, 1504, 682, 1516, -3116, -3116, - -3116, -3116, -3116, 1564, -3116, 1564, 1564, -3116, -3116, -3116, - -3116, 1515, 1515, 1524, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, 1528, 1285, -3116, - 1564, -3116, 1515, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - 72761, -3116, -3116, -3116, -3116, 611, 642, -3116, 1530, -3116, - -3116, -3116, -3116, 1531, -3116, 1517, 1988, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, 6167, 692, 1515, 2571, - -3116, -3116, 20881, 20881, -3116, -3116, 1534, 45512, 1556, -3116, - -3116, 20881, 20881, -3116, -3116, -3116, -3116, 2029, -3116, 20881, - 1564, 1564, -3116, 7693, -3116, 40241, 17737, 1617, 1620, 2029, - -3116, 2029, -3116, 7693, 2032, 2032, 38247, -3116, 1685, 45124, - -3116, 1536, 2660, 6825, 1538, 1533, -3116, 1545, 1540, -3116, - -3116, 42362, 192, -101, -101, 20881, -3116, 2029, 20881, 7324, - 7324, -3116, 218, 70814, 20881, 20881, 20881, 20881, 20881, 20881, - 20881, 20881, 46427, 1624, 172, 65834, 20881, 20881, 1552, 929, - -3116, 20881, 1775, -3116, 1560, 20881, 1648, 319, 20881, 20881, - 20881, 20881, 20881, 20881, 20881, 20881, 20881, -3116, -3116, 29265, - 238, 612, 1897, 1928, -3, 290, 20881, 1918, 11973, -3116, - 1918, -3116, -3116, -3116, -3116, -3116, 223, -3116, -3116, 1504, - 1504, -3116, 65834, -3116, 55889, 297, 51905, 20881, -3116, -3116, - 1575, 1577, 544, -3116, 1636, -3116, -3116, 55889, -3116, 38745, - 56387, 56387, -3116, 1879, -3116, 321, 1578, -3116, 8657, 1832, - 1879, 881, -3116, -3116, 26645, 1710, 1876, 1816, -3116, -3116, - 1801, 1802, -3116, 1602, 45805, 21929, 21929, -3116, 1416, 45512, - 1420, -3116, -3116, -3116, -3116, -3116, -3116, 768, -3116, 55889, - 109, 36255, -3116, 1604, 178, -3116, 3020, 1943, 1906, 1740, - 721, 1615, -3116, 1715, 1623, 69818, 55889, 1903, 1866, 1904, - -74, 70814, -3116, -3116, -3116, -3116, 55889, 65834, 64355, 70316, - 48419, 55889, 47921, -3116, -3116, -3116, -3116, 55889, 1135, 55889, - 6905, -3116, -3116, -3116, -3116, 240, -3116, -3116, -3116, -3116, - -3116, 65834, 55889, -3116, -3116, 240, 65834, 55889, 240, -3116, - 1844, 55889, 55889, 55889, 55889, 1851, 55889, 55889, 1043, -3116, - -3116, -3116, 22453, 53, 53, 1855, 13545, 132, -3116, 20881, - 20881, 936, 249, 65834, 1798, -3116, -3116, 738, 1867, 252, - -3116, 1683, 55889, 55889, 55889, 55889, 65834, 55889, 1297, -3116, - -3116, -3116, -3116, -3116, 1639, -3116, 1642, 2008, 907, -3116, - 2009, 51407, 786, 3977, 2010, 1689, 2012, 14069, 2129, 2018, - 2169, 1657, 1898, -3116, -3116, 1886, -3116, 65834, 2174, -3116, - 111, -3116, 47921, -3116, 125, -3116, 1888, 190, -3116, 15641, - 20881, -3116, -3116, -3116, -3116, -3116, -3116, 1273, 29774, -3116, - 739, -3116, -3116, 2140, 1043, 2140, 774, -3116, -3116, 2140, - -3116, 2122, 2140, -3116, 70814, -3116, 7252, -3116, 20881, 20881, - -3116, 20881, 2013, -3116, 2175, 2175, 70814, 25597, 25597, 25597, - 25597, 25597, 25597, 206, 1355, 25597, 25597, 25597, 25597, 25597, - 25597, 25597, 25597, 25597, 27169, 414, -3116, -3116, 757, 2150, - 20881, 20881, 2024, 2013, 20881, -3116, 70814, 1674, -3116, 1684, - 1688, 20881, -3116, 70814, -3116, 55889, 1691, 16, -2, -3116, - 1677, 1693, -3116, 1611, -3116, 794, 980, 55889, 2914, 3759, - 4406, -3116, -3116, 20881, 2019, 3313, 32270, -3116, 20881, 1695, - -3116, -3116, 32270, 2036, -3116, -3116, -3116, 36753, 3313, 70814, - 772, -3116, 55889, 70814, 776, 20881, -3116, 15641, 2210, 70814, - 2176, 65834, 65834, 2211, 1702, 1703, 2029, 1790, -3116, 1791, - 1792, 1795, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, 70814, -3116, -3116, -3116, -3116, 174, -3116, -3116, - -3116, -3116, 1711, 1716, 20881, 20881, 108, -3116, 7589, 1713, - 1719, 5027, -3116, 1698, -3116, 1717, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, 1708, -3116, 1728, -3116, 1732, 1745, 1748, - 1733, 1734, 55889, -3116, 22977, -3116, 65834, -3116, -3116, 20881, - 20881, 55889, -3116, 1730, -3116, 1735, 1737, 7889, -3116, -3116, - -3116, 239, 873, 6681, 290, 5574, 5574, 5574, 7693, -3116, - -3116, -3116, 1758, -3116, 25597, 25597, -3116, 4166, 1572, 10925, - -3116, -3116, 2087, -3116, 1070, -3116, 1746, -3116, -3116, 2254, - -3116, 40241, 45888, 20881, 186, -3116, 20881, 1552, 20881, 1829, - 5574, 5574, 5574, 298, 298, 239, 239, 239, 873, 290, - -3116, -3116, -3116, 1747, 20881, 47921, -3116, 1749, 1750, 2119, - 1357, 20881, -3116, -3116, 32270, 1544, 12, 1544, 2029, 7324, - -3116, 1010, -3116, -3116, 1010, 45512, 55889, -3116, -3116, 2026, - 1765, 32270, 1810, 2249, 2232, 65834, -3116, -3116, 1771, 1918, - 1797, 1828, 1828, -3116, -3116, -3116, -3116, 1800, 20881, 1268, - 1800, -3116, 1879, 0, 2006, 1081, 1081, 1416, 2007, -3116, - -3116, 1852, -3116, -3116, -3116, 20881, 14593, 1424, -3116, 1436, - -3116, -3116, -3116, -3116, -3116, 1809, -3116, 2061, -3116, 55889, - -3116, -3116, 25597, 2250, 20881, 37251, 2257, 2065, -3116, -3116, - -3116, 1901, 1417, 20881, 2058, -3116, 155, 1819, 2185, -63, - 2136, 65834, -3116, 299, 301, -3116, 209, 2188, 190, 2189, - 190, 47921, 47921, 47921, 778, -3116, -3116, -3116, 1043, -3116, - 374, 796, -3116, -3116, -3116, -3116, 1912, 684, 907, 1417, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, 164, 784, 1417, - 1913, -3116, 1914, -3116, 1916, 879, 1417, -3116, -3116, 1656, - 9351, 45512, 581, 132, 132, 132, 15641, -3116, 2066, 2067, - 1833, 45512, 45512, 152, -3116, -3116, -3116, -3116, 1837, -3116, - 376, -3116, 65834, -3116, -3116, -3116, 1798, 1858, 55889, 907, - 1839, 2315, 1187, 1466, 1786, -3116, 2002, 459, 171, -3116, - 65834, 55889, 55889, 55889, 64853, -3116, -3116, -3116, 1840, 1845, - -3116, 7, 2071, 2079, 55889, 1882, 55889, 1411, 2323, 55889, - -3116, 797, 18261, 65834, -3116, 47921, 2218, 55889, 1818, -3116, - -3116, -3116, -3116, 65834, -3116, -3116, 45512, -3116, -3116, 20881, - 48917, -3116, -3116, -3116, -3116, -3116, -3116, 47921, -3116, 1043, - -3116, 1043, 2092, 65834, 42860, 1043, 43358, 1043, 1859, -3116, - 45512, 8332, 45512, 2024, -3116, 207, 2175, 2097, 2097, 2097, - 3941, 2201, 226, 1865, 2097, 2097, 2097, 337, 337, 207, - 207, 207, 2175, 414, 917, 49913, 1869, -3116, 45512, 45512, - -3116, -3116, 1861, -3116, -3116, -3116, -3116, 1863, 1872, -3116, - -3116, -3116, -3116, -3116, -3116, 65834, 1101, 1544, 449, 449, - 449, 449, -3116, 55889, 55889, 55889, 45512, 2316, 2198, -3116, - 3313, 45512, 55889, -3116, 28217, 55889, -3116, 2220, -3116, 2311, - -3116, 55889, 804, -3116, -3116, -3116, 828, 1877, 1703, 70814, - 845, 870, -3116, 2029, 145, 1875, 1547, 1561, 485, 1434, - -3116, 52901, -3116, -3116, 1878, 45288, 20881, -3116, 2251, -3116, - -3116, -3116, 20881, 20881, -3116, 40241, -3116, -3116, -3116, -3116, - -66, -66, 1885, 10925, 45417, -3116, 2196, 8458, 45512, -3116, - 1685, -3116, -3116, 7324, 20881, 1226, 3108, 20881, 1890, 20881, - 2225, -3116, -3116, 1887, -3116, -3116, 70814, 20881, 1891, 3263, - 25597, 25597, 4145, -3116, 5674, 20881, 10925, -3116, 41428, 1892, - 1889, 1855, 18785, -3116, 2109, 1893, -3116, 2019, 132, 2019, - 1894, -3116, -3116, -3116, -3116, 2571, -3116, 20881, 2054, 65834, - 507, 916, 900, -3116, -101, 38745, 1810, 20881, -3116, -3116, - 258, -3116, -3116, 1896, -3116, 1800, -3116, -3116, -3116, 2126, - -3116, -3116, -3116, 55889, -3116, 1900, -3116, 36255, 2240, 11449, - -3116, 36255, 55889, 55889, 8525, 2270, -3116, 65834, 65834, 65834, - -3116, 65834, 1902, 1907, 877, 1910, 375, -3116, 2784, 877, - 2248, 269, 1411, 262, 3458, 34, -3116, -3116, -3116, 1987, - 55889, -3116, 65834, -3116, -3116, -3116, -3116, -3116, 48419, -3116, - -3116, 39742, 47921, -3116, 47921, 55889, 55889, 55889, 55889, 55889, - 55889, 55889, 55889, 55889, 55889, 1273, 20881, -3116, 20881, 1915, - 1920, 1921, 1855, -3116, -3116, -3116, 205, -3116, 1911, -3116, - -3116, -3116, -84, -3116, 376, 1919, -3116, 51407, 4038, 1689, - 2392, 1923, 1858, 696, 65336, -3116, 1926, 1925, 923, 907, - 1924, 2407, -3116, 786, 51407, -3116, -3116, -3116, 2363, -3116, - 788, 210, -3116, 1187, -3116, 4038, 1466, -3116, 4038, 45512, - 1786, 948, 65834, 1994, -3116, 190, 965, -3116, -3116, -3116, - -3116, -3116, 65834, 1933, -3116, 1933, -3116, -3116, 1933, -3116, - -3116, -3116, -3116, 25597, 2283, 1940, 70814, -3116, -3116, 55889, - -3116, -3116, -3116, 976, 1942, 2019, 55889, 55889, 55889, 55889, - -3116, -3116, -3116, 19309, 20881, 1980, -3116, 1944, 12497, 2264, - -3116, 27693, -3116, -3116, 1947, 36753, 65834, -3116, -3116, -3116, - -3116, 2029, -3116, -3116, 65834, -3116, 1951, -3116, 1954, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, 20881, 45512, - -3116, 45512, -3116, -3116, -3116, -3116, -3116, 6735, -3116, 1950, - 1959, 65834, 20881, -3116, -3116, -3116, 746, 20881, 20881, 4166, - -3116, 45935, 20881, 70814, 984, 4166, 243, 20881, 3633, 4607, - 20881, 20881, 5828, 40747, -3116, 23501, 15117, -3116, 1961, 20881, - 40786, 39243, -3116, 32270, 2198, 1962, 2198, 1043, 1966, 45512, - 20881, -3116, -3116, -3116, -3116, 2025, -20, 33764, 2197, -3116, - 1984, 65834, -3116, 2054, 45512, -3116, -3116, 40241, -3116, -3116, - -3116, -3116, -3116, 2434, 2707, 1978, 1981, -3116, 1353, -3116, - -3116, 65834, 1985, -3116, 1990, 877, -3116, 65834, 2022, -3116, - 256, 2293, 113, -3116, 20881, -3116, 2388, 2466, 2784, 1995, - 65834, 55889, 25597, -3116, 285, 215, -3116, 2288, 55889, 2022, - 2433, -3116, -3116, -3116, 375, -3116, 2331, 2244, -3116, 240, - -3116, 20881, 375, 2246, 266, 65834, -3116, -3116, 3248, -3116, - 70814, 190, 190, -3116, 1516, 2011, 2014, 2015, 2016, 2020, - 2023, 2033, 2035, 2037, 2039, -3116, 2047, 2050, 2051, 2055, - 2056, 2057, 2059, 2068, 1528, 2070, -3116, 2074, 1896, 2075, - 2077, 2078, 2081, 2085, 71780, 2099, 2101, 2102, 2103, 1530, - 2105, 528, 1013, -3116, -3116, -3116, -3116, 2107, -3116, -3116, - -3116, 1235, 2021, -3116, -3116, -3116, 2098, -3116, 2100, -3116, - -3116, -3116, -3116, -3116, -3116, 2027, 2028, -3116, -3116, -3116, - 132, 2030, 2062, 65834, 1273, 116, 65834, 2072, 1882, 2492, - 19833, 47921, 884, 2262, 2034, -3116, 1043, 1689, -3116, 51407, - 4016, 421, 2079, -3116, 279, 1882, -3116, 2431, 1689, 2089, - 2501, -3116, 2110, -3116, 2255, 65834, 2111, -3116, -3116, 48917, - 1933, 4946, 25597, 70814, 985, 993, -3116, 2577, 2276, 2198, - -3116, -3116, -3116, -3116, -3116, 2118, -23, 2125, 10401, 2095, - -3116, -3116, -3116, -3116, -3116, -3116, 45512, 45512, 65834, 2309, - -3116, -3116, 2130, 2131, 37749, 2587, 2132, -3116, -3116, 2448, - -3116, 30774, -3116, 1703, 2138, 1703, 70814, 1703, -3116, -3116, - 45512, 20881, -3116, -3116, 41514, 2460, 4166, 4166, 45935, 1014, - -3116, 4166, 20881, 20881, 4166, 4166, 20881, -3116, 9876, 595, - -3116, 1016, -3116, 40825, -3116, 72263, -3116, -3116, 1980, 1043, - 1980, -3116, -3116, 2134, -3116, -3116, -3116, 2194, -3116, -3116, - 1018, 2570, 2054, 20881, -3116, -3116, 2156, 36255, -3116, -3116, - -3116, -3116, 36255, 877, -3116, 2328, 2022, 2159, -3116, -3116, - -3116, -3116, -3116, -3116, 40872, -3116, 43, 20881, -3116, 770, - 3941, -3116, -3116, -3116, -3116, 2022, 1187, -3116, 55889, 2637, - 2526, -3116, -3116, 45512, -3116, -3116, 2029, 2029, -3116, -3116, - 2311, -3116, -3116, 2160, -3116, -3116, 1235, 634, 39742, 55889, - 55889, -3116, -3116, 2162, -3116, -3116, -3116, -3116, -3116, -84, - 2558, 1052, 786, -3116, 4038, 4038, 45512, 1058, 55889, 2531, - 51407, -3116, 2644, 2167, 55889, 1882, 355, 355, -3116, 2317, - -3116, 2320, -3116, -3116, 2651, 371, -3116, 20357, 47921, 55889, - -3116, -3116, 33266, -3116, 4946, 1060, -3116, -3116, 2178, 2177, - -3116, 1980, 20881, 2183, 20881, -3116, 24025, 2652, 2172, -3116, - 20881, 2247, 28741, -3116, 20881, -3116, 55889, 60869, 2186, 60869, - -3116, -3116, -3116, -3116, -3116, 20881, -3116, 4166, 4166, 4166, - 20881, -3116, 20881, -3116, -3116, -3116, 2395, 2309, -3116, 2309, - 20881, 4038, -101, 3413, 65834, 17, -3116, 45512, -3116, -3116, - -3116, 55889, -3116, 47921, -3116, 877, -29, 2190, 20881, 40911, - 2430, -3116, -3116, 2462, -3116, 2521, -3116, 2256, 643, 2272, - -3116, -3116, -3116, -3116, 1273, 1043, 1689, 2079, 2089, -3116, - -3116, 2199, 55889, 4038, 786, 788, -3116, -3116, -3116, -3116, - -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, -3116, 4038, - 2641, 2425, 2645, 4038, 45512, 1072, 1994, 20881, 101, -3116, - 1079, 2642, -3116, -3116, 2712, 2309, 2205, 24025, 2206, -3116, - 2208, 65834, 45512, 2357, -3116, -3116, 2212, -3116, -3116, 20881, - -3116, 41867, 2213, 2216, 2674, 1855, 2247, 2247, -3116, -20, - -3116, -3116, 2646, 33266, 2602, 1187, 877, 2231, 1084, -3116, - -3116, -3116, -3116, -3116, 907, -3116, 41264, 2465, 645, 2451, - 2190, 20881, -3116, 2300, -3116, -3116, -3116, 2705, -3116, -3116, - 51407, 2229, 2089, 2079, 1882, 2089, 2454, -3116, 2456, -3116, - -3116, 2233, 41350, 65834, 65834, 1689, 33266, 65834, 2234, 2247, - -3116, 2235, -3116, -3116, -3116, 54893, -3116, 2238, -3116, -3116, - -3116, 20881, 166, -3116, -3116, 2289, 55889, 1108, 28, 2462, - 39742, -3116, 47921, 1455, -29, 2552, -3116, -3116, -3116, -3116, - 156, 2468, -3116, 2469, -3116, 45512, -3116, 4038, 51407, -3116, - -3116, -3116, -3116, -3116, -3116, 33266, 2642, -3116, 321, -3116, - 1544, -3116, 321, -3116, -3116, -3116, -3116, -3116, 1494, 24549, - 24549, 24549, 2242, 4038, -3116, 1544, -3116, 2379, 2451, -3116, - -3116, -3116, -3116, -3116, 478, 478, 2648, -3116, 2318, -3116, - 2089, 1122, 65834, 1800, -3116, 1800, 26121, 2403, 224, 44390, - 2625, -3116, 2625, 2625, -3116, -3116, -3116, 38745, -3116, -3116, - 2749, -3116, 247, -3116, -3116, -3116, 1689, 321, -3116, -3116, - 2740, -3116, -3116, -3116, -3116, -3116, 147, -3116, -3116, -3116, - 1544, 877, -3116, -3116, -3116, 1544, 1800, 25073, 2410, -3116, - 2481, -3116, -3116, -3116, -3116, -3116, -3116, -3116 + 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, 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, 4, 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, 3, 3, + 2, 2, 2, 1, 1, 0, 2, 2, 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, 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, + 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, 1, 1, 2, 4, 2, 2, 3, + 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, 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, 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, 4, 6, 6, 0, 1, 1, + 1, 0, 2, 2, 4, 6, 5, 4, 6, 1, + 1, 1, 1, 1, 1, 0, 1, 3, 1, 0, + 7, 3, 1, 2, 3, 2, 0, 2, 0, 2, + 4, 5, 8, 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, 1, 1, 1 }; -/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. - Performed when YYTABLE does not specify something else to do. Zero +/* 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[] = { - 156, 265, 0, 1392, 1391, 1464, 265, 0, 1326, 0, - 265, 488, 403, 0, 1485, 1484, 0, 208, 265, 0, - 156, 0, 1425, 0, 0, 0, 551, 554, 552, 0, - 0, 0, 265, 591, 0, 1486, 265, 0, 0, 583, - 553, 0, 1442, 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, 1349, 28, 29, 30, 31, 0, 32, - 0, 33, 34, 35, 36, 527, 513, 596, 526, 0, - 0, 155, 695, 534, 37, 39, 38, 40, 41, 42, - 43, 44, 1487, 1483, 45, 264, 263, 257, 0, 0, - 0, 0, 0, 1463, 0, 0, 258, 112, 1511, 1512, - 1513, 1514, 1515, 1516, 1517, 1518, 1519, 1520, 1521, 1888, - 1522, 1523, 1524, 1525, 1526, 1889, 1527, 1528, 1529, 1834, - 1835, 1890, 1836, 1837, 1530, 1531, 1532, 1533, 1534, 1535, - 1536, 1537, 1538, 1539, 1838, 1839, 1540, 1541, 1542, 1543, - 1544, 1840, 1891, 1841, 1545, 1546, 1547, 1548, 1549, 1892, - 1550, 1551, 1552, 1553, 1554, 1555, 1556, 1557, 1558, 1893, - 1559, 1560, 1561, 1562, 1563, 1564, 1565, 1566, 1567, 1568, - 1842, 1569, 1570, 1843, 1571, 1572, 1573, 1574, 1575, 1576, - 1577, 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, - 1587, 1588, 1589, 1590, 1591, 1592, 1593, 1594, 1595, 1596, - 1597, 1844, 1598, 1599, 1600, 1601, 1602, 1603, 1845, 1604, - 1605, 1606, 1846, 1607, 1608, 1609, 1894, 1895, 1610, 1611, - 1847, 1897, 1612, 1613, 1848, 1849, 1614, 1615, 1616, 1617, - 1618, 1619, 1620, 1621, 1622, 1898, 1623, 1624, 1625, 1626, - 1627, 1628, 1629, 1630, 1631, 1632, 1633, 1634, 1899, 1850, - 1635, 1636, 1637, 1638, 1639, 1851, 1852, 1853, 1640, 1900, - 1901, 1641, 1902, 1642, 1643, 1644, 1645, 1646, 1647, 1648, - 1903, 1649, 1904, 1650, 1651, 1652, 1653, 1654, 1655, 1656, - 1657, 1854, 1658, 1659, 1660, 1661, 1662, 1663, 1664, 1665, - 1666, 1667, 1668, 1669, 1670, 1671, 1672, 1673, 1674, 1675, - 1676, 1677, 1855, 1906, 1856, 1678, 1679, 1680, 1857, 1681, - 1682, 1907, 1683, 1858, 1684, 1859, 1685, 1686, 1687, 1688, - 1689, 1690, 1691, 1692, 1693, 1694, 1860, 1908, 1695, 1909, - 1861, 1696, 1697, 1698, 1699, 1700, 1701, 1702, 1703, 1704, - 1705, 1706, 1707, 1708, 1862, 1910, 1709, 1710, 1863, 1711, - 1712, 1713, 1714, 1715, 1716, 1717, 1718, 1719, 1720, 1721, - 1722, 1723, 1724, 1864, 1725, 1726, 1727, 1728, 1729, 1730, - 1731, 1732, 1733, 1734, 1735, 1736, 1737, 1738, 1739, 1740, - 1741, 1742, 1743, 1911, 1744, 1745, 1746, 1865, 1747, 1748, - 1749, 1750, 1751, 1752, 1753, 1754, 1755, 1756, 1757, 1758, - 1759, 1760, 1761, 1762, 1763, 1764, 1765, 1866, 1766, 1767, - 1912, 1768, 1769, 1867, 1770, 1771, 1772, 1773, 1774, 1775, - 1776, 1777, 1778, 1779, 1780, 1781, 1782, 1868, 1783, 1869, - 1784, 1785, 1786, 1914, 1787, 1788, 1789, 1790, 1791, 1792, - 1870, 1871, 1793, 1794, 1872, 1795, 1873, 1796, 1797, 1874, - 1798, 1799, 1800, 1801, 1802, 1803, 1804, 1805, 1806, 1807, - 1808, 1809, 1810, 1811, 1812, 1813, 1814, 1875, 1876, 1815, - 1915, 1816, 1817, 1818, 1819, 1820, 1821, 1822, 1823, 1824, - 1825, 1826, 1827, 1828, 1829, 1877, 1878, 1879, 1880, 1881, - 1882, 1883, 1884, 1885, 1886, 1887, 1830, 1831, 1832, 1833, - 0, 113, 114, 1273, 1494, 0, 1251, 112, 1847, 1854, - 1868, 1324, 1325, 113, 0, 260, 487, 0, 0, 0, - 0, 0, 0, 210, 0, 397, 396, 0, 1315, 402, - 0, 0, 0, 116, 108, 1711, 115, 1250, 106, 122, - 2058, 2059, 2060, 2061, 1945, 2062, 2063, 2064, 2065, 1946, - 2066, 1947, 1948, 1949, 1950, 1951, 1952, 2067, 2068, 2069, - 1954, 1953, 2070, 1955, 2071, 1956, 2072, 1957, 1958, 2073, - 2074, 1959, 1565, 1960, 1961, 2075, 2076, 2077, 2078, 2079, - 2080, 2081, 2082, 2083, 1962, 1963, 2084, 2085, 1964, 2086, - 2087, 1965, 2088, 1966, 1967, 1968, 2089, 2090, 1969, 1970, - 2091, 1971, 2092, 2093, 1972, 1973, 1976, 1974, 2094, 1975, - 2095, 1977, 1978, 1979, 2096, 2097, 1980, 1981, 2098, 1982, - 1983, 1984, 1985, 1986, 2099, 1987, 2100, 1988, 1989, 2101, - 2102, 2103, 2104, 2105, 1991, 1990, 1992, 1993, 2106, 2107, - 2108, 2109, 1994, 1995, 1996, 2110, 2111, 1997, 2112, 2113, - 1998, 1999, 2114, 2000, 2001, 2115, 2002, 2003, 2116, 2004, - 2005, 2117, 2118, 2119, 2006, 2120, 2007, 2008, 2121, 2122, - 2009, 2010, 2123, 2011, 2124, 2125, 2126, 2127, 2012, 2013, - 2128, 2014, 2129, 2130, 2131, 2132, 2015, 2016, 2017, 2018, - 2019, 2020, 2021, 2022, 2023, 2024, 2025, 1460, 124, 123, - 125, 0, 421, 422, 0, 432, 0, 414, 419, 415, - 0, 441, 434, 442, 423, 413, 435, 424, 412, 209, - 0, 443, 429, 417, 0, 0, 0, 0, 261, 222, - 403, 0, 156, 0, 1353, 1354, 1355, 1356, 1357, 1358, - 1363, 1359, 1360, 1361, 1362, 1364, 1365, 1366, 1367, 1368, - 1344, 1349, 1369, 1370, 1371, 1372, 1373, 1374, 1375, 1376, - 1377, 1378, 1379, 1380, 1381, 1382, 1383, 0, 1326, 0, - 1840, 1891, 1845, 0, 1858, 0, 1861, 1862, 1747, 1869, - 1872, 1873, 1874, 1875, 0, 765, 115, 110, 749, 0, - 529, 699, 709, 749, 754, 1036, 777, 1037, 0, 117, - 1427, 1426, 1420, 195, 1288, 1472, 1612, 1652, 1764, 1870, - 1793, 1490, 1473, 1467, 1471, 262, 590, 588, 0, 1222, - 1612, 1652, 1751, 1764, 1870, 1400, 1404, 0, 259, 1492, - 1477, 0, 1478, 115, 535, 582, 0, 266, 1441, 0, - 1446, 0, 1727, 562, 565, 1282, 563, 527, 0, 0, - 1, 156, 1348, 1456, 0, 162, 0, 0, 586, 586, - 0, 586, 0, 519, 0, 0, 527, 522, 526, 696, - 1489, 1870, 1793, 1476, 1479, 1621, 0, 0, 1621, 0, - 1621, 0, 1621, 0, 0, 1466, 1206, 0, 1252, 118, - 0, 0, 1337, 1333, 1338, 1334, 1339, 1332, 1331, 1340, - 1336, 0, 0, 0, 368, 401, 400, 399, 398, 403, - 1621, 1299, 0, 450, 451, 0, 0, 0, 0, 0, - 206, 1310, 109, 107, 1621, 1461, 430, 431, 0, 420, - 416, 418, 0, 0, 1621, 1277, 440, 436, 1621, 440, - 1244, 1621, 0, 0, 214, 0, 396, 1346, 1384, 2012, - 1385, 1386, 1398, 0, 1399, 1389, 1352, 156, 0, 486, - 1323, 0, 0, 0, 1157, 749, 754, 0, 0, 767, - 0, 1177, 0, 1183, 0, 0, 0, 749, 534, 0, - 709, 766, 111, 0, 747, 748, 637, 637, 591, 0, - 572, 759, 0, 0, 762, 760, 0, 762, 0, 0, - 0, 762, 758, 717, 0, 637, 0, 747, 750, 637, - 0, 769, 1343, 0, 0, 0, 0, 1470, 1468, 1469, - 1474, 0, 0, 0, 1254, 1256, 1257, 1125, 1267, 1015, - 0, 1835, 1836, 1837, 1198, 1838, 1839, 1841, 1842, 1843, - 974, 1585, 1844, 1265, 1846, 1848, 1849, 1851, 1852, 1853, - 1854, 1855, 1856, 0, 1266, 1859, 1690, 1864, 1865, 1867, - 1870, 1871, 1264, 1876, 0, 0, 0, 1233, 1148, 0, - 1014, 0, 0, 0, 1199, 1207, 1007, 0, 0, 813, - 814, 835, 836, 815, 841, 842, 844, 816, 0, 1229, - 908, 1003, 1217, 1012, 1020, 1016, 1055, 1018, 1035, 1021, - 1092, 1013, 0, 1019, 1005, 1225, 572, 1223, 0, 1006, - 1253, 572, 1221, 1403, 1401, 1407, 1402, 0, 0, 0, - 0, 0, 111, 1448, 1449, 1440, 1438, 1439, 1437, 1436, - 1443, 0, 1445, 1349, 1143, 1145, 0, 564, 0, 0, - 0, 516, 515, 517, 3, 1282, 0, 0, 0, 1602, - 0, 1428, 584, 585, 0, 0, 0, 0, 0, 0, - 0, 0, 680, 611, 612, 614, 677, 681, 689, 0, - 0, 0, 0, 0, 523, 0, 1488, 1482, 1480, 0, - 0, 0, 140, 140, 0, 0, 0, 0, 0, 100, - 49, 93, 0, 0, 0, 0, 236, 249, 0, 0, - 0, 0, 0, 246, 0, 0, 229, 223, 225, 51, - 0, 140, 0, 47, 0, 0, 0, 53, 1464, 0, - 486, 1205, 0, 120, 121, 119, 112, 0, 2026, 1888, - 1889, 1890, 1891, 1841, 1892, 1893, 0, 1894, 1895, 1847, - 1897, 1898, 1899, 1900, 1901, 1902, 1903, 1904, 1854, 1906, - 1907, 1908, 1909, 1910, 1911, 2052, 1912, 1868, 1914, 1874, - 0, 1915, 1028, 113, 1270, 1151, 596, 1149, 1283, 0, - 0, 1335, 0, 0, 0, 0, 484, 0, 0, 0, - 0, 1295, 0, 0, 1621, 202, 1621, 368, 0, 1621, - 368, 1621, 0, 1621, 207, 211, 1309, 1312, 0, 433, - 428, 426, 425, 427, 1621, 255, 0, 0, 1278, 438, - 439, 0, 407, 0, 0, 409, 0, 0, 219, 0, - 217, 0, 403, 156, 0, 230, 1394, 1395, 1393, 0, - 0, 1351, 233, 1388, 1397, 1387, 1396, 1350, 250, 1345, - 0, 0, 1341, 473, 0, 0, 0, 1158, 884, 883, - 865, 866, 881, 882, 867, 868, 875, 876, 886, 885, - 873, 874, 869, 870, 863, 864, 879, 880, 871, 872, - 877, 878, 861, 862, 1172, 1159, 1160, 1161, 1162, 1163, - 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1171, 0, 0, - 708, 706, 0, 0, 0, 0, 0, 0, 1199, 0, - 978, 1013, 0, 0, 0, 1143, 1182, 0, 0, 0, - 0, 0, 0, 1143, 1188, 0, 0, 733, 745, 0, - 630, 636, 707, 705, 0, 1222, 700, 0, 779, 759, - 0, 758, 0, 0, 761, 755, 0, 756, 0, 0, - 0, 0, 757, 0, 0, 0, 0, 703, 0, 745, - 0, 704, 776, 1410, 1418, 196, 0, 1274, 1916, 1917, - 1918, 823, 1919, 852, 830, 852, 852, 1920, 1921, 1922, - 1923, 819, 819, 832, 1924, 1925, 1926, 1927, 1928, 820, - 821, 857, 1929, 1930, 1931, 1932, 1933, 0, 0, 1934, - 852, 1935, 819, 1936, 1937, 1938, 824, 1939, 787, 1940, - 0, 1941, 822, 788, 1942, 860, 860, 1943, 0, 847, - 1944, 1275, 1276, 0, 1154, 797, 805, 806, 807, 808, - 833, 834, 809, 839, 840, 810, 907, 0, 819, 156, - 1475, 1491, 0, 1148, 1022, 851, 838, 1197, 0, 846, - 845, 0, 1148, 828, 827, 826, 1009, 0, 825, 1105, - 852, 852, 850, 933, 829, 0, 0, 0, 0, 0, - 856, 0, 854, 934, 912, 913, 0, 1232, 1241, 1143, - 1147, 0, 1007, 1143, 0, 0, 1095, 1097, 0, 1024, - 1025, 0, 1200, 1255, 1008, 0, 1260, 0, 0, 907, - 907, 1228, 1125, 0, 1115, 1118, 0, 0, 1122, 1123, - 1124, 0, 0, 0, 1220, 0, 1133, 1135, 0, 0, - 949, 1131, 0, 952, 0, 0, 0, 0, 1119, 1120, - 1121, 1111, 1112, 1113, 1114, 1116, 1117, 1129, 1110, 930, - 0, 1004, 0, 1058, 0, 929, 1226, 698, 0, 1258, - 698, 1412, 1416, 1417, 1415, 1411, 0, 1406, 1405, 1408, - 1409, 1493, 0, 1450, 1434, 0, 1431, 1146, 693, 566, - 1246, 0, 570, 1457, 1455, 161, 160, 0, 213, 0, - 0, 0, 1421, 539, 538, 605, 597, 599, 605, 0, - 537, 0, 653, 654, 0, 0, 0, 0, 686, 684, - 1254, 1267, 641, 615, 640, 0, 0, 619, 0, 645, - 908, 679, 521, 609, 610, 613, 520, 0, 682, 0, - 692, 0, 558, 560, 543, 557, 555, 540, 548, 680, - 614, 0, 1481, 0, 0, 0, 0, 0, 1621, 0, - 0, 790, 84, 65, 320, 139, 0, 0, 0, 0, - 0, 0, 0, 92, 89, 90, 91, 0, 0, 0, - 0, 1274, 234, 235, 248, 0, 239, 240, 237, 241, - 242, 0, 0, 227, 228, 0, 0, 0, 0, 226, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1465, - 1458, 1201, 1206, 596, 596, 596, 0, 594, 595, 0, - 0, 0, 0, 0, 472, 366, 376, 0, 0, 0, - 1299, 0, 0, 0, 0, 0, 206, 0, 403, 1300, - 1298, 1302, 1301, 1303, 1591, 190, 0, 0, 201, 198, - 0, 365, 339, 0, 0, 1314, 0, 0, 0, 0, - 0, 0, 1621, 355, 1311, 0, 1462, 0, 0, 253, - 440, 1279, 0, 437, 440, 1245, 0, 440, 221, 0, - 0, 1347, 1390, 231, 251, 232, 252, 486, 481, 511, - 0, 489, 494, 470, 0, 470, 0, 491, 495, 470, - 490, 0, 470, 485, 0, 1051, 0, 1041, 0, 0, - 768, 0, 0, 1042, 980, 981, 0, 0, 0, 0, + 156, 265, 0, 1395, 1394, 1467, 265, 0, 1329, 0, + 265, 491, 406, 0, 1488, 1487, 0, 208, 265, 0, + 156, 0, 1428, 0, 0, 0, 554, 557, 555, 0, + 0, 0, 265, 594, 0, 1489, 265, 0, 0, 586, + 556, 0, 1445, 0, 0, 0, 0, 0, 2, 4, + 7, 21, 35, 31, 0, 20, 33, 18, 17, 38, + 26, 6, 24, 37, 40, 19, 25, 15, 39, 13, + 36, 530, 516, 599, 529, 0, 0, 155, 698, 537, + 34, 16, 30, 5, 11, 12, 28, 29, 27, 1352, + 43, 32, 0, 41, 22, 8, 9, 23, 42, 44, + 1490, 1486, 10, 45, 14, 264, 263, 257, 0, 0, + 0, 0, 0, 1466, 0, 0, 268, 112, 1514, 1515, + 1516, 1517, 1518, 1519, 1520, 1521, 1522, 1523, 1524, 1891, + 1525, 1526, 1527, 1528, 1529, 1892, 1530, 1531, 1532, 1837, + 1838, 1893, 1839, 1840, 1533, 1534, 1535, 1536, 1537, 1538, + 1539, 1540, 1541, 1542, 1841, 1842, 1543, 1544, 1545, 1546, + 1547, 1843, 1894, 1844, 1548, 1549, 1550, 1551, 1552, 1895, + 1553, 1554, 1555, 1556, 1557, 1558, 1559, 1560, 1561, 1896, + 1562, 1563, 1564, 1565, 1566, 1567, 1568, 1569, 1570, 1571, + 1845, 1572, 1573, 1846, 1574, 1575, 1576, 1577, 1578, 1579, + 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, + 1590, 1591, 1592, 1593, 1594, 1595, 1596, 1597, 1598, 1599, + 1600, 1847, 1601, 1602, 1603, 1604, 1605, 1606, 1848, 1607, + 1608, 1609, 1849, 1610, 1611, 1612, 1897, 1898, 1613, 1614, + 1850, 1900, 1615, 1616, 1851, 1852, 1617, 1618, 1619, 1620, + 1621, 1622, 1623, 1624, 1625, 1901, 1626, 1627, 1628, 1629, + 1630, 1631, 1632, 1633, 1634, 1635, 1636, 1637, 1902, 1853, + 1638, 1639, 1640, 1641, 1642, 1854, 1855, 1856, 1643, 1903, + 1904, 1644, 1905, 1645, 1646, 1647, 1648, 1649, 1650, 1651, + 1906, 1652, 1907, 1653, 1654, 1655, 1656, 1657, 1658, 1659, + 1660, 1857, 1661, 1662, 1663, 1664, 1665, 1666, 1667, 1668, + 1669, 1670, 1671, 1672, 1673, 1674, 1675, 1676, 1677, 1678, + 1679, 1680, 1858, 1909, 1859, 1681, 1682, 1683, 1860, 1684, + 1685, 1910, 1686, 1861, 1687, 1862, 1688, 1689, 1690, 1691, + 1692, 1693, 1694, 1695, 1696, 1697, 1863, 1911, 1698, 1912, + 1864, 1699, 1700, 1701, 1702, 1703, 1704, 1705, 1706, 1707, + 1708, 1709, 1710, 1711, 1865, 1913, 1712, 1713, 1866, 1714, + 1715, 1716, 1717, 1718, 1719, 1720, 1721, 1722, 1723, 1724, + 1725, 1726, 1727, 1867, 1728, 1729, 1730, 1731, 1732, 1733, + 1734, 1735, 1736, 1737, 1738, 1739, 1740, 1741, 1742, 1743, + 1744, 1745, 1746, 1914, 1747, 1748, 1749, 1868, 1750, 1751, + 1752, 1753, 1754, 1755, 1756, 1757, 1758, 1759, 1760, 1761, + 1762, 1763, 1764, 1765, 1766, 1767, 1768, 1869, 1769, 1770, + 1915, 1771, 1772, 1870, 1773, 1774, 1775, 1776, 1777, 1778, + 1779, 1780, 1781, 1782, 1783, 1784, 1785, 1871, 1786, 1872, + 1787, 1788, 1789, 1917, 1790, 1791, 1792, 1793, 1794, 1795, + 1873, 1874, 1796, 1797, 1875, 1798, 1876, 1799, 1800, 1877, + 1801, 1802, 1803, 1804, 1805, 1806, 1807, 1808, 1809, 1810, + 1811, 1812, 1813, 1814, 1815, 1816, 1817, 1878, 1879, 1818, + 1918, 1819, 1820, 1821, 1822, 1823, 1824, 1825, 1826, 1827, + 1828, 1829, 1830, 1831, 1832, 1880, 1881, 1882, 1883, 1884, + 1885, 1886, 1887, 1888, 1889, 1890, 1833, 1834, 1835, 1836, + 0, 1497, 0, 1254, 113, 114, 1276, 112, 1850, 1857, + 1871, 1328, 1327, 113, 0, 260, 490, 0, 0, 0, + 0, 0, 0, 210, 0, 400, 399, 0, 1318, 405, + 0, 0, 0, 116, 108, 1714, 115, 1253, 106, 122, + 2061, 2062, 2063, 2064, 1948, 2065, 2066, 2067, 2068, 1949, + 2069, 1950, 1951, 1952, 1953, 1954, 1955, 2070, 2071, 2072, + 1957, 1956, 2073, 1958, 2074, 1959, 2075, 1960, 1961, 2076, + 2077, 1962, 1568, 1963, 1964, 2078, 2079, 2080, 2081, 2082, + 2083, 2084, 2085, 2086, 1965, 1966, 2087, 2088, 1967, 2089, + 2090, 1968, 2091, 1969, 1970, 1971, 2092, 2093, 1972, 1973, + 2094, 1974, 2095, 2096, 1975, 1976, 1979, 1977, 2097, 1978, + 2098, 1980, 1981, 1982, 2099, 2100, 1983, 1984, 2101, 1985, + 1986, 1987, 1988, 1989, 2102, 1990, 2103, 1991, 1992, 2104, + 2105, 2106, 2107, 2108, 1994, 1993, 1995, 1996, 2109, 2110, + 2111, 2112, 1997, 1998, 1999, 2113, 2114, 2000, 2115, 2116, + 2001, 2002, 2117, 2003, 2004, 2118, 2005, 2006, 2119, 2007, + 2008, 2120, 2121, 2122, 2009, 2123, 2010, 2011, 2124, 2125, + 2012, 2013, 2126, 2014, 2127, 2128, 2129, 2130, 2015, 2016, + 2131, 2017, 2132, 2133, 2134, 2135, 2018, 2019, 2020, 2021, + 2022, 2023, 2024, 2025, 2026, 2027, 2028, 1463, 124, 123, + 125, 0, 424, 425, 0, 435, 0, 417, 422, 418, + 0, 444, 437, 445, 426, 416, 438, 427, 415, 209, + 0, 446, 432, 420, 0, 0, 0, 0, 261, 222, + 406, 0, 156, 0, 1358, 1368, 1377, 1373, 1367, 1375, + 1365, 1381, 1371, 1357, 1379, 1366, 1370, 1363, 1380, 1361, + 1378, 1376, 1364, 1372, 1356, 1360, 1347, 1352, 1384, 1374, + 1382, 1369, 1383, 1385, 1359, 1386, 1362, 0, 1329, 0, + 1843, 1894, 1848, 0, 1861, 0, 1864, 1865, 1750, 1872, + 1875, 1876, 1877, 1878, 0, 768, 115, 110, 752, 0, + 532, 702, 712, 752, 757, 1039, 780, 1040, 0, 117, + 1430, 1429, 1423, 195, 1291, 1475, 1615, 1655, 1767, 1873, + 1796, 1493, 1476, 1470, 1474, 262, 593, 591, 0, 1225, + 1615, 1655, 1754, 1767, 1873, 1403, 1407, 0, 268, 1495, + 1480, 0, 1481, 115, 538, 585, 0, 269, 1444, 0, + 1449, 0, 1730, 565, 568, 1285, 566, 530, 0, 0, + 1, 156, 0, 162, 0, 589, 589, 0, 589, 0, + 522, 0, 0, 530, 525, 529, 699, 1351, 1459, 0, + 1492, 1873, 1796, 1479, 1482, 1624, 0, 0, 1624, 0, + 1624, 0, 1624, 0, 0, 1469, 0, 258, 1209, 0, + 1255, 118, 0, 0, 1340, 1336, 1341, 1337, 1342, 1335, + 1334, 1343, 1339, 0, 0, 0, 371, 404, 403, 402, + 401, 406, 1624, 1302, 0, 206, 453, 454, 0, 0, + 0, 0, 0, 1313, 109, 107, 1624, 1464, 433, 434, + 0, 423, 419, 421, 0, 0, 1624, 1280, 443, 439, + 1624, 443, 1247, 1624, 0, 0, 214, 0, 399, 1349, + 1387, 2015, 1401, 0, 1402, 1392, 1355, 1388, 1389, 156, + 0, 489, 1326, 0, 0, 0, 1160, 752, 757, 0, + 0, 770, 0, 1180, 0, 1186, 0, 0, 0, 752, + 537, 0, 712, 769, 111, 0, 750, 751, 640, 640, + 594, 0, 575, 762, 0, 0, 765, 763, 0, 765, + 0, 0, 0, 765, 761, 720, 0, 640, 0, 750, + 753, 640, 0, 772, 1346, 0, 0, 0, 0, 1473, + 1471, 1472, 1477, 0, 0, 0, 1257, 1259, 1260, 1128, + 1270, 1018, 0, 1838, 1839, 1840, 1201, 1841, 1842, 1844, + 1845, 1846, 977, 1588, 1847, 1268, 1849, 1851, 1852, 1854, + 1855, 1856, 1857, 1858, 1859, 0, 1269, 1862, 1693, 1867, + 1868, 1870, 1873, 1874, 1267, 1879, 0, 0, 0, 1236, + 1151, 0, 1017, 0, 0, 0, 1202, 1210, 1010, 0, + 0, 816, 817, 838, 839, 818, 844, 845, 847, 819, + 0, 1232, 911, 1006, 1220, 1015, 1023, 1019, 1058, 1021, + 1038, 1024, 1095, 1016, 0, 1022, 1008, 1228, 575, 1226, + 0, 1009, 1256, 575, 1224, 1406, 1404, 1410, 1405, 0, + 0, 0, 0, 259, 0, 111, 1452, 1451, 1443, 1441, + 1442, 1440, 1439, 1446, 0, 1448, 1352, 1146, 1148, 0, + 567, 0, 0, 0, 519, 518, 520, 3, 0, 0, + 0, 1605, 0, 587, 588, 0, 0, 0, 0, 0, + 0, 0, 0, 683, 614, 615, 617, 680, 684, 692, + 0, 0, 0, 0, 0, 526, 0, 1285, 1431, 1491, + 1485, 1483, 0, 0, 0, 140, 140, 0, 0, 0, + 0, 0, 100, 49, 93, 0, 0, 0, 0, 236, + 249, 0, 0, 0, 0, 0, 246, 0, 0, 229, + 51, 223, 225, 0, 140, 0, 47, 0, 0, 0, + 53, 1467, 0, 489, 266, 267, 1208, 0, 120, 121, + 119, 112, 0, 2029, 1891, 1892, 1893, 1894, 1844, 1895, + 1896, 0, 1897, 1898, 1850, 1900, 1901, 1902, 1903, 1904, + 1905, 1906, 1907, 1857, 1909, 1910, 1911, 1912, 1913, 1914, + 2055, 1915, 1871, 1917, 1877, 0, 1918, 1031, 1154, 599, + 1152, 1286, 0, 113, 1273, 0, 1338, 0, 0, 0, + 0, 487, 0, 0, 0, 0, 1298, 0, 1624, 207, + 211, 0, 1624, 202, 1624, 371, 0, 1624, 371, 1624, + 0, 1312, 1315, 0, 436, 431, 429, 428, 430, 1624, + 255, 0, 0, 1281, 441, 442, 0, 410, 0, 0, + 412, 0, 0, 219, 0, 217, 0, 406, 156, 0, + 230, 1397, 1398, 1396, 0, 0, 1391, 1354, 233, 250, + 1400, 1390, 1399, 1353, 1348, 0, 0, 1344, 476, 0, + 0, 0, 1161, 887, 886, 868, 869, 884, 885, 870, + 871, 878, 879, 889, 888, 876, 877, 872, 873, 866, + 867, 882, 883, 874, 875, 880, 881, 864, 865, 1175, + 1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1171, + 1172, 1173, 1174, 0, 0, 711, 709, 0, 0, 0, + 0, 0, 0, 1202, 0, 981, 1016, 0, 0, 0, + 1146, 1185, 0, 0, 0, 0, 0, 0, 1146, 1191, + 0, 0, 736, 748, 0, 633, 639, 710, 708, 0, + 1225, 703, 0, 782, 0, 762, 0, 761, 0, 0, + 764, 758, 0, 759, 0, 0, 0, 0, 760, 0, + 0, 0, 0, 0, 706, 0, 748, 0, 707, 779, + 1413, 1421, 196, 0, 1277, 1919, 1920, 1921, 826, 1922, + 855, 833, 855, 855, 1923, 1924, 1925, 1926, 822, 822, + 835, 1927, 1928, 1929, 1930, 1931, 823, 824, 860, 1932, + 1933, 1934, 1935, 1936, 0, 0, 1937, 855, 1938, 822, + 1939, 1940, 1941, 827, 1942, 790, 1943, 0, 1944, 825, + 791, 1945, 863, 863, 1946, 0, 850, 1947, 0, 1157, + 800, 808, 809, 810, 811, 836, 837, 812, 842, 843, + 813, 910, 0, 822, 1278, 1279, 156, 1478, 1494, 0, + 1151, 1025, 854, 841, 1200, 0, 849, 848, 0, 1151, + 831, 830, 829, 1012, 0, 828, 1108, 855, 855, 853, + 936, 832, 0, 0, 0, 0, 0, 859, 0, 857, + 937, 915, 916, 0, 1235, 1244, 1146, 1150, 0, 1010, + 1146, 0, 0, 1098, 1100, 0, 1027, 1028, 0, 1203, + 1258, 1011, 0, 1263, 0, 0, 910, 910, 1231, 1128, + 0, 1118, 1121, 0, 0, 1125, 1126, 1127, 0, 0, + 0, 1223, 0, 1136, 1138, 0, 0, 952, 1134, 0, + 955, 0, 0, 0, 0, 1122, 1123, 1124, 1114, 1115, + 1116, 1117, 1119, 1120, 1132, 1113, 933, 0, 1007, 0, + 1061, 0, 932, 1229, 701, 0, 1261, 701, 1415, 1419, + 1420, 1414, 1418, 0, 1409, 1408, 1411, 1412, 1496, 0, + 1453, 1437, 0, 1434, 1149, 696, 569, 1249, 0, 573, + 1458, 161, 160, 0, 213, 0, 542, 541, 608, 600, + 602, 608, 0, 540, 0, 656, 657, 0, 0, 0, + 0, 689, 687, 1257, 1270, 644, 618, 643, 0, 0, + 622, 0, 648, 911, 682, 524, 612, 613, 616, 523, + 0, 685, 0, 695, 0, 561, 563, 546, 560, 558, + 543, 551, 683, 617, 0, 1460, 0, 0, 1424, 1484, + 0, 0, 0, 0, 0, 1624, 0, 0, 793, 84, + 65, 323, 139, 0, 0, 0, 0, 0, 0, 0, + 92, 89, 90, 91, 0, 0, 0, 0, 1277, 234, + 235, 248, 0, 239, 240, 237, 241, 242, 0, 0, + 227, 228, 0, 0, 0, 0, 226, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1468, 1461, 1204, 1209, + 599, 599, 599, 0, 597, 598, 0, 0, 0, 0, + 0, 475, 369, 379, 0, 0, 0, 1302, 206, 0, + 0, 0, 0, 0, 0, 406, 1305, 1303, 1301, 1304, + 1306, 1594, 190, 0, 0, 0, 0, 0, 198, 201, + 0, 368, 342, 0, 0, 1317, 0, 0, 0, 1624, + 358, 1314, 0, 1465, 0, 0, 253, 443, 1282, 0, + 440, 443, 1248, 0, 443, 221, 0, 0, 1350, 1393, + 231, 251, 232, 252, 489, 484, 514, 0, 492, 497, + 473, 0, 473, 0, 494, 498, 473, 493, 0, 473, + 488, 0, 1054, 0, 1044, 0, 0, 771, 0, 0, + 1045, 983, 984, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 998, 997, 1043, 772, 0, 775, - 0, 0, 1180, 1181, 0, 1044, 0, 0, 1187, 0, - 0, 0, 1049, 0, 710, 0, 0, 0, 625, 629, - 632, 0, 635, 572, 528, 1612, 1652, 0, 583, 583, - 583, 581, 571, 0, 657, 0, 0, 734, 0, 0, - 736, 738, 0, 0, 741, 716, 715, 0, 0, 0, - 0, 780, 0, 1250, 0, 0, 197, 0, 0, 0, - 805, 0, 0, 0, 795, 791, 0, 887, 888, 889, - 890, 891, 892, 893, 894, 895, 896, 897, 898, 899, - 811, 1287, 0, 817, 1292, 1293, 1290, 0, 1286, 1289, - 1291, 1294, 0, 0, 0, 0, 1196, 1192, 0, 0, - 0, 0, 1100, 1102, 1104, 0, 849, 848, 1109, 1115, - 1118, 1122, 1123, 1124, 1119, 1120, 1121, 1111, 1112, 1113, - 1114, 1116, 1117, 0, 1137, 0, 1091, 0, 0, 0, - 0, 0, 0, 1231, 0, 976, 0, 1026, 1011, 0, - 0, 1098, 1027, 1233, 1208, 0, 0, 0, 1263, 1262, - 909, 918, 921, 953, 954, 925, 926, 927, 931, 1285, - 1284, 1227, 0, 1219, 0, 0, 910, 935, 940, 0, - 1189, 970, 0, 958, 0, 948, 0, 956, 960, 936, - 951, 0, 932, 0, 1220, 1134, 1136, 0, 1132, 0, - 922, 923, 924, 914, 915, 916, 917, 919, 920, 928, - 1108, 1106, 1107, 0, 1206, 0, 1218, 0, 0, 1060, - 0, 0, 955, 1224, 0, 779, 596, 779, 0, 907, - 1451, 1282, 1444, 1433, 1282, 1144, 1247, 1281, 568, 0, - 0, 0, 1453, 147, 151, 0, 1207, 181, 183, 698, - 0, 1428, 1428, 1430, 1429, 603, 604, 608, 0, 0, - 608, 587, 536, 1865, 1747, 0, 0, 0, 0, 646, - 687, 0, 678, 643, 644, 0, 642, 1254, 647, 1253, - 648, 651, 652, 620, 1242, 688, 690, 0, 683, 0, - 1248, 542, 561, 0, 0, 0, 0, 0, 525, 524, - 694, 0, 50, 0, 1621, 67, 0, 0, 0, 0, - 0, 0, 270, 0, 370, 270, 105, 1621, 440, 1621, - 440, 1515, 1586, 1765, 0, 63, 344, 96, 0, 133, - 373, 0, 329, 86, 101, 126, 0, 0, 224, 52, - 238, 243, 129, 247, 244, 1319, 245, 140, 0, 48, - 0, 127, 0, 1317, 0, 0, 54, 131, 1321, 1466, - 0, 1205, 0, 594, 594, 594, 0, 1150, 0, 0, - 0, 1152, 1153, 948, 1328, 1329, 1330, 1327, 458, 471, - 0, 367, 0, 483, 461, 462, 472, 1297, 0, 202, - 368, 0, 368, 0, 211, 1299, 0, 0, 192, 188, - 0, 0, 0, 0, 366, 358, 356, 389, 0, 363, - 357, 0, 0, 315, 0, 1509, 0, 0, 0, 0, - 452, 0, 0, 206, 212, 0, 0, 0, 255, 256, - 406, 1280, 408, 0, 410, 220, 218, 1342, 478, 1148, - 0, 476, 482, 475, 477, 480, 474, 0, 469, 0, - 504, 0, 0, 0, 0, 0, 0, 0, 0, 1038, - 1156, 0, 1175, 1174, 979, 986, 989, 993, 994, 995, - 1176, 0, 0, 0, 990, 991, 992, 982, 983, 984, - 985, 987, 988, 996, 777, 0, 0, 771, 1185, 1184, - 1178, 1179, 0, 1046, 1047, 1048, 1186, 0, 0, 746, - 623, 621, 624, 626, 622, 0, 0, 779, 583, 583, - 583, 583, 580, 0, 0, 0, 778, 0, 674, 740, - 0, 764, 0, 737, 720, 0, 728, 0, 735, 784, - 751, 0, 0, 753, 1419, 801, 0, 796, 792, 0, - 0, 0, 802, 0, 0, 0, 0, 0, 0, 0, - 1155, 0, 589, 1023, 0, 0, 0, 1193, 0, 975, - 818, 831, 0, 1103, 1017, 0, 1126, 1090, 859, 858, - 860, 860, 0, 0, 0, 1240, 0, 1144, 1094, 1096, - 1241, 1010, 843, 907, 0, 0, 0, 0, 0, 0, - 0, 959, 950, 0, 957, 961, 0, 0, 0, 944, - 0, 0, 942, 971, 938, 0, 0, 972, 1205, 0, - 1209, 0, 0, 1059, 1068, 701, 697, 657, 594, 657, - 0, 1413, 1435, 1432, 569, 156, 1454, 0, 170, 0, - 0, 0, 0, 173, 187, 184, 1453, 0, 1422, 1423, - 0, 598, 600, 0, 1127, 608, 602, 650, 649, 0, - 618, 685, 616, 0, 691, 0, 559, 0, 545, 0, - 719, 0, 0, 0, 0, 0, 319, 0, 0, 0, - 270, 0, 378, 0, 385, 0, 0, 370, 351, 85, - 0, 0, 0, 59, 104, 77, 69, 55, 83, 0, - 0, 88, 0, 81, 98, 99, 97, 102, 0, 280, - 305, 0, 0, 316, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 486, 1206, 1202, 1206, 0, - 0, 0, 596, 592, 593, 1029, 0, 457, 510, 507, - 508, 506, 229, 377, 0, 0, 200, 365, 0, 1314, - 0, 0, 1296, 403, 0, 193, 0, 191, 0, 202, - 368, 0, 343, 339, 364, 337, 336, 338, 0, 1510, - 222, 0, 1504, 368, 1313, 0, 0, 453, 0, 447, - 211, 0, 0, 1308, 254, 440, 0, 465, 505, 512, - 492, 497, 0, 503, 499, 498, 493, 501, 500, 496, - 1039, 1050, 1173, 0, 0, 0, 0, 770, 773, 0, - 1045, 1040, 744, 0, 0, 657, 0, 0, 0, 0, - 574, 573, 579, 0, 0, 1062, 739, 0, 0, 0, - 726, 714, 721, 722, 0, 0, 0, 782, 781, 752, - 805, 0, 785, 805, 0, 805, 0, 803, 0, 812, - 900, 901, 902, 903, 904, 905, 906, 837, 0, 1195, - 1191, 1099, 1101, 1138, 855, 853, 1230, 1143, 1235, 1237, - 0, 0, 0, 1093, 977, 1261, 911, 0, 0, 941, - 1190, 962, 0, 0, 0, 937, 1126, 0, 0, 0, - 0, 0, 946, 0, 1213, 1206, 0, 1212, 0, 0, - 0, 0, 1034, 702, 674, 0, 674, 0, 0, 1452, - 0, 1447, 148, 149, 150, 0, 0, 0, 165, 142, - 0, 0, 182, 170, 158, 606, 607, 0, 601, 617, - 1243, 1249, 544, 0, 1007, 0, 0, 541, 0, 134, - 270, 0, 0, 66, 0, 387, 331, 379, 362, 346, - 0, 0, 0, 271, 0, 404, 0, 0, 352, 0, - 0, 0, 0, 332, 0, 0, 291, 0, 0, 362, - 0, 369, 287, 288, 0, 58, 78, 0, 74, 0, - 103, 0, 0, 0, 0, 0, 61, 73, 0, 56, - 0, 440, 440, 64, 1274, 1916, 1917, 1918, 1919, 1920, - 1921, 1922, 1923, 1924, 1925, 2036, 1926, 1927, 1928, 1929, - 1930, 1931, 1932, 1933, 2045, 1934, 277, 1935, 1690, 1936, - 1937, 1938, 1939, 1940, 0, 1941, 788, 1942, 1943, 2124, - 1944, 1111, 1112, 275, 276, 372, 272, 1275, 273, 380, - 274, 0, 375, 330, 130, 1320, 0, 128, 0, 1318, - 137, 135, 132, 1322, 1459, 0, 0, 1032, 1033, 1030, - 594, 0, 0, 0, 486, 464, 0, 0, 1509, 0, - 0, 0, 0, 1621, 0, 189, 0, 1314, 199, 365, - 0, 395, 315, 390, 0, 1509, 1507, 0, 1314, 1503, - 0, 444, 0, 203, 0, 0, 0, 411, 479, 0, - 502, 999, 0, 0, 0, 0, 633, 0, 639, 674, - 578, 577, 576, 575, 656, 1560, 1848, 1746, 0, 660, - 655, 658, 663, 665, 664, 666, 662, 673, 0, 676, - 763, 1139, 1141, 0, 0, 0, 0, 727, 729, 0, - 731, 0, 783, 799, 0, 800, 0, 798, 793, 804, - 1194, 1238, 1239, 1234, 0, 908, 968, 966, 963, 0, - 964, 945, 0, 0, 943, 939, 0, 973, 0, 0, - 1210, 0, 1054, 0, 1057, 1071, 1067, 1066, 1062, 1029, - 1062, 1414, 567, 169, 146, 172, 171, 0, 1207, 179, - 0, 0, 170, 0, 174, 454, 0, 0, 556, 718, - 549, 550, 0, 383, 68, 0, 362, 0, 270, 348, - 347, 350, 345, 349, 0, 405, 0, 0, 289, 0, - 296, 334, 335, 333, 290, 362, 368, 292, 0, 0, - 0, 70, 60, 57, 62, 71, 0, 0, 72, 75, - 784, 87, 80, 1274, 2045, 2054, 0, 0, 0, 0, - 0, 1204, 1203, 0, 460, 459, 509, 456, 467, 229, - 0, 0, 339, 1506, 0, 0, 449, 0, 0, 0, - 365, 194, 0, 0, 0, 1509, 0, 0, 267, 0, - 312, 0, 215, 1508, 0, 0, 1495, 0, 0, 0, - 1306, 1307, 0, 466, 1000, 0, 1001, 774, 0, 0, - 631, 1062, 0, 0, 0, 667, 661, 0, 1061, 1063, - 0, 628, 1142, 723, 0, 725, 0, 749, 0, 749, - 732, 794, 786, 1236, 1052, 0, 965, 969, 967, 947, - 1206, 1214, 1206, 1211, 1056, 1070, 1073, 676, 1259, 676, - 0, 0, 157, 0, 0, 154, 141, 159, 1128, 546, - 547, 0, 270, 0, 361, 384, 301, 279, 0, 0, - 0, 286, 293, 394, 295, 0, 79, 95, 0, 0, - 374, 138, 136, 1031, 486, 0, 1314, 315, 1503, 446, - 205, 0, 0, 0, 339, 222, 1505, 328, 321, 322, - 323, 324, 325, 326, 327, 342, 341, 313, 314, 0, - 0, 0, 0, 0, 448, 0, 1308, 0, 176, 185, - 0, 176, 1002, 634, 0, 676, 0, 0, 0, 659, - 0, 0, 675, 0, 532, 1140, 0, 713, 711, 0, - 712, 0, 0, 0, 0, 596, 628, 628, 143, 0, - 144, 180, 0, 0, 0, 368, 386, 360, 0, 353, - 299, 298, 300, 304, 0, 302, 0, 318, 0, 311, - 279, 0, 82, 0, 381, 455, 463, 0, 269, 1497, - 365, 0, 1503, 315, 1509, 1503, 0, 1500, 0, 445, - 204, 0, 0, 0, 178, 1314, 0, 178, 0, 628, - 669, 0, 668, 1065, 1064, 630, 724, 0, 1053, 1216, - 1215, 0, 1077, 531, 530, 0, 0, 0, 0, 394, - 0, 340, 0, 0, 301, 0, 294, 391, 392, 393, - 0, 307, 297, 308, 76, 94, 382, 0, 365, 1498, - 268, 216, 1496, 1501, 1502, 0, 176, 175, 605, 177, - 779, 186, 605, 638, 533, 670, 627, 730, 1072, 0, - 0, 0, 0, 0, 153, 779, 164, 0, 311, 359, - 354, 278, 303, 317, 0, 0, 0, 309, 0, 310, - 1503, 0, 178, 608, 1304, 608, 1834, 1561, 1800, 0, - 1089, 1078, 1089, 1089, 1069, 145, 152, 0, 270, 283, - 0, 282, 0, 371, 306, 1499, 1314, 605, 166, 167, - 0, 1082, 1081, 1080, 1084, 1083, 0, 1076, 1074, 1075, - 779, 388, 281, 285, 284, 779, 608, 0, 0, 1086, - 0, 1087, 163, 1305, 168, 1079, 1085, 1088 + 0, 1001, 1000, 1046, 775, 0, 778, 0, 0, 1183, + 1184, 0, 1047, 0, 0, 1190, 0, 0, 0, 1052, + 0, 713, 0, 0, 0, 628, 632, 635, 0, 638, + 575, 531, 1615, 1655, 0, 586, 586, 586, 584, 574, + 0, 660, 0, 0, 0, 737, 0, 0, 739, 741, + 0, 0, 744, 0, 719, 718, 0, 0, 0, 0, + 783, 0, 1253, 0, 0, 197, 0, 0, 0, 808, + 0, 0, 0, 798, 794, 0, 890, 891, 892, 893, + 894, 895, 896, 897, 898, 899, 900, 901, 902, 814, + 1290, 0, 820, 1293, 0, 1294, 1295, 1292, 1289, 1296, + 1297, 0, 0, 0, 0, 1199, 1195, 0, 0, 0, + 0, 1103, 1105, 1107, 0, 852, 851, 1112, 1118, 1121, + 1125, 1126, 1127, 1122, 1123, 1124, 1114, 1115, 1116, 1117, + 1119, 1120, 0, 1140, 0, 1094, 0, 0, 0, 0, + 0, 0, 1234, 0, 979, 0, 1029, 1014, 0, 0, + 1101, 1030, 1236, 1211, 0, 0, 0, 1266, 1265, 912, + 921, 924, 956, 957, 928, 929, 930, 934, 1288, 1287, + 1230, 0, 1222, 0, 0, 913, 938, 943, 0, 1192, + 973, 0, 961, 0, 951, 0, 959, 963, 939, 954, + 0, 935, 0, 1223, 1137, 1139, 0, 1135, 0, 925, + 926, 927, 917, 918, 919, 920, 922, 923, 931, 1111, + 1109, 1110, 0, 1209, 0, 1221, 0, 0, 1063, 0, + 0, 958, 1227, 0, 782, 599, 782, 0, 910, 1454, + 1285, 1447, 1285, 1436, 1147, 1250, 1284, 571, 0, 0, + 0, 1456, 147, 151, 0, 1210, 181, 183, 701, 0, + 606, 607, 611, 0, 0, 611, 590, 539, 1868, 1750, + 0, 0, 0, 0, 649, 690, 0, 681, 646, 647, + 0, 645, 1257, 650, 1256, 651, 654, 655, 623, 1245, + 691, 693, 0, 686, 0, 1251, 545, 564, 0, 0, + 0, 0, 0, 528, 527, 697, 1431, 1431, 1433, 1432, + 0, 50, 0, 1624, 67, 0, 0, 0, 0, 0, + 0, 273, 0, 373, 273, 105, 1624, 443, 1624, 443, + 1518, 1589, 1768, 0, 63, 347, 96, 0, 133, 376, + 0, 332, 86, 101, 126, 0, 0, 52, 224, 238, + 243, 129, 247, 244, 1322, 245, 140, 0, 48, 0, + 127, 0, 1320, 0, 0, 54, 131, 1324, 1469, 0, + 1208, 0, 597, 597, 597, 0, 1153, 0, 0, 0, + 1155, 1156, 951, 1332, 1331, 1333, 1330, 461, 474, 0, + 370, 0, 486, 464, 465, 475, 1300, 211, 0, 202, + 371, 0, 371, 0, 1302, 0, 0, 192, 188, 206, + 212, 0, 0, 0, 0, 0, 369, 361, 359, 392, + 0, 366, 360, 0, 0, 318, 0, 1512, 0, 0, + 0, 0, 455, 0, 0, 0, 0, 255, 256, 409, + 1283, 411, 0, 413, 220, 218, 1345, 481, 1151, 0, + 479, 485, 480, 483, 478, 477, 0, 472, 0, 507, + 0, 0, 0, 0, 0, 0, 0, 0, 1041, 1159, + 0, 1178, 1177, 982, 989, 992, 996, 997, 998, 1179, + 0, 0, 0, 993, 994, 995, 985, 986, 987, 988, + 990, 991, 999, 780, 0, 0, 774, 1188, 1187, 1181, + 1182, 0, 1049, 1050, 1051, 1189, 0, 0, 749, 626, + 624, 627, 629, 625, 0, 0, 782, 586, 586, 586, + 586, 583, 0, 0, 0, 781, 0, 677, 745, 743, + 0, 767, 0, 740, 723, 746, 0, 731, 0, 738, + 787, 754, 0, 0, 756, 1422, 804, 0, 799, 795, + 0, 0, 0, 805, 0, 0, 0, 0, 0, 0, + 0, 1158, 0, 592, 1026, 0, 0, 0, 1196, 0, + 978, 821, 834, 0, 1106, 1020, 0, 1129, 1093, 862, + 861, 863, 863, 0, 0, 0, 1243, 0, 1147, 1097, + 1099, 1244, 1013, 846, 910, 0, 0, 0, 0, 0, + 0, 0, 962, 953, 0, 960, 964, 0, 0, 0, + 947, 0, 0, 945, 974, 941, 0, 0, 975, 1208, + 0, 1212, 0, 0, 1062, 1071, 704, 700, 660, 597, + 660, 0, 1416, 1438, 1435, 572, 156, 1457, 0, 170, + 0, 0, 0, 0, 173, 187, 184, 1456, 0, 0, + 601, 603, 0, 1130, 611, 605, 653, 652, 0, 621, + 688, 619, 0, 694, 0, 562, 0, 548, 0, 722, + 0, 0, 1425, 1426, 0, 0, 0, 322, 0, 0, + 0, 273, 0, 381, 0, 388, 0, 0, 373, 354, + 85, 0, 0, 0, 59, 104, 77, 69, 55, 83, + 0, 0, 88, 0, 81, 98, 99, 97, 102, 0, + 283, 308, 0, 0, 319, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 489, 1209, 1205, 1209, + 0, 0, 0, 599, 595, 596, 1032, 0, 460, 513, + 510, 511, 509, 229, 380, 0, 0, 0, 200, 368, + 0, 1317, 0, 1299, 406, 0, 193, 0, 191, 211, + 0, 0, 202, 371, 0, 346, 342, 367, 340, 339, + 341, 0, 1513, 222, 0, 1507, 371, 1316, 0, 0, + 456, 0, 450, 0, 1311, 254, 443, 0, 468, 508, + 515, 495, 500, 0, 506, 502, 501, 496, 504, 503, + 499, 1042, 1053, 1176, 0, 0, 0, 0, 773, 776, + 0, 1048, 1043, 747, 0, 0, 660, 0, 0, 0, + 0, 577, 576, 582, 0, 0, 1065, 742, 0, 0, + 0, 729, 717, 724, 725, 0, 0, 0, 785, 784, + 755, 808, 0, 788, 808, 0, 808, 0, 806, 0, + 815, 903, 904, 905, 906, 907, 908, 909, 840, 0, + 1198, 1194, 1102, 1104, 1141, 858, 856, 1233, 1146, 1238, + 1240, 0, 0, 0, 1096, 980, 1264, 914, 0, 0, + 944, 1193, 965, 0, 0, 0, 940, 1129, 0, 0, + 0, 0, 0, 949, 0, 1216, 1209, 0, 1215, 0, + 0, 0, 0, 1037, 705, 677, 0, 677, 0, 0, + 1455, 0, 1450, 148, 149, 150, 0, 0, 0, 165, + 142, 0, 0, 182, 170, 158, 609, 610, 0, 604, + 620, 1246, 1252, 547, 0, 1010, 0, 0, 544, 0, + 134, 273, 0, 0, 66, 0, 390, 334, 382, 365, + 349, 0, 0, 0, 274, 0, 407, 0, 0, 355, + 0, 0, 0, 0, 335, 0, 0, 294, 0, 0, + 365, 0, 372, 290, 291, 0, 58, 78, 0, 74, + 0, 103, 0, 0, 0, 0, 0, 61, 73, 0, + 56, 0, 443, 443, 64, 1277, 1919, 1920, 1921, 1922, + 1923, 1924, 1925, 1926, 1927, 1928, 2039, 1929, 1930, 1931, + 1932, 1933, 1934, 1935, 1936, 2048, 1937, 280, 1938, 1693, + 1939, 1940, 1941, 1942, 1943, 0, 1944, 791, 1945, 1946, + 2127, 1947, 1114, 1115, 279, 278, 375, 275, 383, 277, + 0, 1278, 276, 378, 333, 130, 1323, 0, 128, 0, + 1321, 137, 135, 132, 1325, 1462, 0, 0, 1035, 1036, + 1033, 597, 0, 0, 0, 489, 467, 0, 0, 0, + 1512, 0, 0, 0, 1624, 0, 189, 0, 0, 203, + 1317, 199, 368, 0, 398, 318, 393, 0, 1512, 1510, + 0, 1317, 1506, 0, 447, 0, 0, 0, 414, 482, + 0, 505, 1002, 0, 0, 0, 0, 636, 0, 642, + 677, 581, 580, 579, 578, 659, 1563, 1851, 1749, 0, + 663, 658, 661, 666, 668, 667, 669, 665, 676, 0, + 679, 766, 1142, 1144, 0, 0, 0, 0, 730, 732, + 0, 734, 0, 786, 802, 0, 803, 0, 801, 796, + 807, 1197, 1241, 1242, 1237, 0, 911, 971, 969, 966, + 0, 967, 948, 0, 0, 946, 942, 0, 976, 0, + 0, 1213, 0, 1057, 0, 1060, 1074, 1070, 1069, 1065, + 1032, 1065, 1417, 570, 169, 146, 172, 171, 0, 1210, + 179, 0, 0, 170, 0, 174, 457, 0, 0, 559, + 721, 552, 553, 0, 386, 68, 0, 365, 0, 273, + 351, 350, 353, 348, 352, 0, 408, 0, 0, 292, + 0, 299, 337, 338, 336, 293, 365, 371, 295, 0, + 0, 0, 70, 60, 57, 62, 71, 0, 0, 72, + 75, 787, 87, 80, 1277, 2048, 2057, 0, 0, 0, + 0, 0, 1207, 1206, 0, 463, 462, 512, 459, 470, + 229, 0, 0, 0, 342, 1509, 0, 0, 452, 0, + 0, 368, 194, 0, 0, 0, 0, 1512, 0, 0, + 270, 0, 315, 0, 215, 1511, 0, 0, 1498, 0, + 0, 1309, 1310, 0, 469, 1003, 0, 1004, 777, 0, + 0, 634, 1065, 0, 0, 0, 670, 664, 0, 1064, + 1066, 0, 631, 1145, 726, 0, 728, 0, 752, 0, + 752, 735, 797, 789, 1239, 1055, 0, 968, 972, 970, + 950, 1209, 1217, 1209, 1214, 1059, 1073, 1076, 679, 1262, + 679, 0, 0, 157, 0, 0, 154, 141, 159, 1131, + 549, 550, 0, 273, 0, 364, 387, 304, 282, 0, + 0, 0, 289, 296, 397, 298, 0, 79, 95, 0, + 0, 377, 138, 136, 1034, 489, 0, 205, 1317, 318, + 1506, 449, 0, 0, 0, 0, 342, 222, 1508, 331, + 324, 325, 326, 327, 328, 329, 330, 345, 344, 316, + 317, 0, 0, 0, 0, 0, 451, 1311, 0, 176, + 185, 0, 176, 1005, 637, 0, 679, 0, 0, 0, + 662, 0, 0, 678, 0, 535, 1143, 0, 716, 714, + 0, 715, 0, 0, 0, 0, 599, 631, 631, 143, + 0, 144, 180, 0, 0, 0, 371, 389, 363, 0, + 356, 302, 301, 303, 307, 0, 305, 0, 321, 0, + 314, 282, 0, 82, 0, 384, 458, 466, 0, 272, + 1500, 368, 0, 204, 1506, 318, 1512, 1506, 0, 1503, + 0, 448, 0, 0, 0, 178, 1317, 0, 178, 0, + 631, 672, 0, 671, 1068, 1067, 633, 727, 0, 1056, + 1219, 1218, 0, 1080, 534, 533, 0, 0, 0, 0, + 397, 0, 343, 0, 0, 304, 0, 297, 394, 395, + 396, 0, 310, 300, 311, 76, 94, 385, 0, 368, + 1501, 271, 216, 1499, 1504, 1505, 0, 176, 175, 608, + 177, 782, 186, 608, 641, 536, 673, 630, 733, 1075, + 0, 0, 0, 0, 0, 153, 782, 164, 0, 314, + 362, 357, 281, 306, 320, 0, 0, 0, 312, 0, + 313, 1506, 0, 178, 611, 1307, 611, 1837, 1564, 1803, + 0, 1092, 1081, 1092, 1092, 1072, 145, 152, 0, 273, + 286, 0, 285, 0, 374, 309, 1502, 1317, 608, 166, + 167, 0, 1085, 1084, 1083, 1087, 1086, 0, 1079, 1077, + 1078, 782, 391, 284, 288, 287, 782, 611, 0, 0, + 1089, 0, 1090, 163, 1308, 168, 1082, 1088, 1091 }; -/* YYPGOTO[NTERM-NUM]. */ -static const yytype_int16 yypgoto[] = +/* YYDEFGOTO[NTERM-NUM]. */ +static const yytype_int16 yydefgoto[] = { - -3116, -3116, -3116, 1917, 80, 84, -898, -1172, -929, -1193, - -3116, -112, 86, -3116, -3116, 191, -3116, 1015, -3116, 173, - -728, 551, -3116, 1116, -3116, -3116, 1557, 521, 87, 95, - 2031, -3116, 989, -3116, 3790, 2554, 3581, 590, -513, -872, - -1226, 1, 10, -3116, -3116, -3116, -3116, -3116, -869, 497, - -1209, -3116, 437, -3116, -3116, -3116, -3116, -201, 157, -2260, - 5, -2158, -2878, -561, -3116, -665, -3116, -317, -3116, -610, - -3116, -961, -617, -650, -2783, -1132, -3116, 1622, -370, -3116, - 591, -3116, -2541, -3116, -3116, 579, -3116, -1149, -3116, -2218, - 159, -598, -2580, -2568, -2157, -882, 229, -603, 213, -2131, - -1285, -3116, 605, -3116, -587, -3116, -880, -2050, 99, -2758, - -1658, -7, -3116, -3116, -3116, -715, -3116, -2500, 102, 1541, - -2143, 106, -1656, -3116, -3116, -1664, 56, -2121, 6, -2115, - 107, -3116, -3116, 120, 18, -574, 287, -3116, 122, -3116, - -3116, 1527, -899, -3116, -3116, 487, 123, 971, -3116, -2561, - -3116, -588, -3116, -608, -638, -3116, -3116, 36, -888, 1502, - -3116, -3116, -3116, 8, -3116, -471, -3116, -3116, -2543, -3116, - 19, -3116, -3116, -3116, -3116, -1486, -407, 295, -3116, -3116, - -547, -2545, -497, -3116, -2974, -3006, -3116, -3116, -642, -2992, - -2051, 126, -3116, 1979, -349, 127, 128, -3116, 314, 133, - -1133, 14, 2, -43, -38, -3116, -34, -3116, -3116, -3116, - 648, -3116, -3116, 4, 52, 1704, -3116, -1023, -3116, -1495, - 533, -3116, 1853, 1860, -2135, -860, -67, -3116, 693, -1661, - -2113, -646, 1127, 1692, 1690, 446, -2940, -3116, -526, -3116, - 165, -3116, -3116, 687, 1179, -1548, -1557, -3116, -2202, -3116, - -438, -325, -3116, -3116, -3116, -3116, -3116, -2494, -2177, -599, - 1153, -3116, 1714, -3116, -3116, -3116, -3116, 35, -1480, 2871, - 734, -77, -3116, -3116, -3116, -3116, 161, -3116, 919, -154, - -3116, 2106, -671, -784, 1929, -228, 170, -1796, -15, 2114, - 494, -3116, -3116, 500, -2016, -1395, 458, -239, 921, -3116, - -3116, -1221, -3116, -1843, -1164, -3116, -3116, -733, -651, -3116, - -3116, -3116, 765, 969, -3116, -3116, 1846, 2049, -3116, -877, - 2073, -863, -1026, 1932, -916, 1934, -918, -920, -925, 1935, - 1936, 1937, 1938, 1939, 1945, 1946, -1531, 4923, 2344, 2886, - -2192, -3116, -2152, 1039, 1046, 21, -3116, -1384, 67, -3116, - -3116, -3116, -3116, -2387, -3116, -405, -3116, -402, -3116, -3116, - -3116, -1636, -3115, -1666, -3116, 2193, 861, -3116, -3116, 450, - -3116, -3116, -3116, -3116, -1514, -3116, 5936, 755, -3116, -2007, - -3116, -3116, -952, -829, -1153, -989, -1215, -1895, -3116, -3116, - -3116, -3116, -3116, -3116, -1485, -1729, -206, 818, -3116, -3116, - 910, -3116, -3116, -3116, -1730, -2095, -3116, -3116, -3116, 825, - 1499, 117, -817, -1594, -3116, 867, -2353, -3116, -3116, 441, - -3116, -604, -1116, -2426, 532, 23, -3116, 1263, -2503, -3116, - -3116, -712, -2657, -1096, -887, -3116, 134, 1644, 26, 135, - -3116, 136, 1267, -3116, -3116, -3116, 139, -3116, 338, 141, - 410, -3116, 958, -3116, 689, 15, -3116, -3116, -3116, 75, - 2843, 11, -2972 + -1, 47, 48, 49, 754, 2616, 2617, 2618, 2253, 1212, + 3383, 2254, 1213, 1214, 2620, 755, 805, 1096, 807, 1097, + 1611, 911, 1248, 1249, 756, 1764, 757, 2839, 2173, 2562, + 3365, 54, 3110, 2176, 1170, 3113, 3330, 2832, 3108, 2563, + 3405, 3459, 3111, 2177, 2178, 3331, 2179, 758, 2677, 2678, + 759, 760, 1848, 58, 1310, 550, 1845, 761, 762, 1343, + 1344, 966, 763, 1849, 1792, 2955, 1232, 1782, 1358, 62, + 1866, 764, 107, 907, 64, 765, 2605, 2956, 3376, 2631, + 3514, 2892, 2893, 3373, 3374, 2608, 2256, 3442, 3443, 2692, + 1773, 3437, 2337, 3317, 2260, 2241, 2894, 2345, 3275, 3004, + 2257, 2874, 2338, 3369, 1861, 2339, 3370, 3129, 2340, 1823, + 1852, 2609, 3444, 2261, 1824, 2604, 2957, 1761, 2341, 3380, + 2342, 551, 2878, 766, 745, 746, 958, 1337, 747, 767, + 942, 1858, 768, 769, 2658, 2315, 3180, 2707, 3181, 2378, + 2309, 1367, 2371, 1886, 1826, 1368, 539, 1900, 2708, 2663, + 1887, 770, 1098, 72, 73, 1012, 74, 3123, 75, 76, + 1735, 1736, 1737, 851, 863, 864, 2169, 1453, 1969, 856, + 1175, 1704, 838, 839, 2299, 879, 1815, 1699, 1700, 2182, + 2570, 1728, 1729, 1184, 1185, 1957, 3345, 1958, 1959, 1446, + 1447, 3221, 1716, 1720, 1721, 2203, 2193, 1707, 2447, 3040, + 3041, 3042, 3043, 3044, 3045, 3046, 1099, 2746, 3232, 1724, + 1725, 1187, 1188, 1189, 1733, 2213, 78, 79, 2154, 2546, + 2547, 811, 3057, 1472, 1738, 2750, 2751, 2752, 3060, 3061, + 3062, 812, 1007, 1008, 1031, 1026, 1461, 1978, 813, 814, + 1934, 1935, 2416, 1033, 1971, 1989, 1990, 2758, 2471, 1538, + 2242, 1539, 1540, 2004, 1541, 1100, 1542, 1570, 1101, 1575, + 1544, 1102, 1103, 1104, 1547, 1105, 1106, 1107, 1108, 1563, + 1109, 1110, 1587, 2006, 2007, 2008, 2009, 2010, 2011, 2012, + 2013, 2014, 2015, 2016, 2017, 2018, 2019, 1157, 1739, 1112, + 1113, 1114, 1115, 1116, 1117, 1118, 1119, 816, 1120, 1121, + 1660, 2148, 2545, 3050, 3229, 3230, 2823, 3098, 3257, 3356, + 3473, 3501, 3502, 3528, 1122, 1123, 1603, 1604, 1605, 2041, + 2042, 2043, 2044, 2142, 1654, 1655, 1124, 2959, 1657, 2064, + 3053, 3054, 1158, 1439, 1598, 1289, 1290, 1552, 1413, 1414, + 1420, 1909, 1428, 1432, 1939, 1940, 1440, 2110, 1125, 2035, + 2036, 2489, 1565, 1126, 1247, 1610, 2818, 2145, 1658, 2104, + 1133, 1127, 1134, 1129, 1594, 1595, 2506, 2790, 2791, 2074, + 2210, 1687, 2215, 2216, 962, 1130, 1131, 1132, 1291, 523, + 1553, 3460, 1333, 1163, 1292, 2100, 771, 1038, 2028, 772, + 1306, 1838, 773, 3212, 3017, 1322, 1862, 2350, 552, 774, + 775, 532, 85, 2304, 923, 86, 87, 88, 888, 1360, + 776, 1361, 1362, 973, 89, 2709, 975, 976, 778, 845, + 846, 1481, 1674, 1482, 779, 92, 822, 1748, 780, 1153, + 860, 1154, 1156, 781, 1172, 2559, 2171, 95, 96, 97, + 115, 1243, 782, 832, 833, 869, 100, 101, 1200, 834, + 852, 784, 785, 3208, 786, 2695, 1316, 533, 525, 526, + 1555, 719, 1294, 720 }; -/* YYDEFGOTO[NTERM-NUM]. */ -static const yytype_int16 yydefgoto[] = +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +#define YYPACT_NINF -3101 +static const int yypact[] = +{ + 6098, -30, 742, -3101, -3101, 312, -30, 49904, 65327, 120, + -30, 114, 4273, 51896, -3101, -3101, 46418, 40133, -30, 55382, + 72708, 475, 557, 31599, 610, 55880, -3101, -3101, -3101, 65327, + 55382, 56378, -30, 336, 65825, -3101, -30, 34089, 52394, 246, + -3101, 55382, 37, 255, 56876, 55382, 3276, 763, 325, -3101, + -3101, -3101, -3101, -3101, 126, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, 138, -3101, 110, 158, 31599, 31599, 927, 379, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, 401, + -3101, -3101, 713, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, 33591, -3101, -3101, -3101, -3101, -3101, -3101, 57374, 55382, + 57872, 52892, 58370, -3101, 677, 959, 629, 169, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + 180, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, 496, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, 185, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + 174, -3101, 504, -3101, 194, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, 1832, -3101, -3101, 929, 2662, 55382, + 765, 784, 690, -3101, 58868, -3101, 695, 55382, -3101, -3101, + 711, 787, 854, -3101, -3101, 53390, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, 46916, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, 859, -3101, -3101, 687, -3101, 156, -3101, -3101, 718, + 661, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + 777, -3101, -3101, -3101, 793, 66323, 59366, 59864, -3101, 666, + 3264, 41214, 72726, 30601, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, 401, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, 55880, 65327, 691, + 697, 1052, 714, 32097, 746, 34588, 753, 758, 1080, 764, + 778, 782, 786, 255, 31100, 801, 174, -3101, 60362, 60362, + -48, 4330, -3101, 60362, 60860, -3101, 816, -3101, 959, -3101, + -3101, -3101, -3101, 556, 820, -3101, 61358, 61358, 61358, 832, + 1117, -3101, -3101, -3101, 830, -3101, -3101, 1065, 20210, 20210, + 66821, 66821, 959, 66821, 876, -3101, -3101, 81, 629, -3101, + -3101, 927, 850, 174, -3101, -3101, 52394, -3101, -3101, 241, + 1226, 20210, 55382, 883, -3101, 895, 883, 898, 968, 985, + -3101, 6098, 1237, 1160, 53888, 342, 342, 1399, 342, 623, + 891, 3257, 2793, -3101, 954, -3101, 994, -3101, 55382, 55880, + 1096, 1030, 1323, -3101, 850, 1411, 1339, 1198, 1415, 4709, + 1426, 1361, 1430, 1391, 1436, 1552, 16, -3101, 20210, 47414, + 174, -3101, 11302, 20210, -3101, -3101, -3101, 1179, -3101, -3101, + -3101, -3101, -3101, 55382, 65327, 1082, 1085, -3101, -3101, -3101, + -3101, 776, 1329, -3101, 1567, 67319, -3101, -3101, 1163, 61856, + 62354, 62852, 63350, 1568, -3101, -3101, 1508, -3101, -3101, -3101, + 1192, -3101, -3101, -3101, 188, 67817, 1529, 1165, 224, -3101, + 1539, 232, -3101, 1543, 1407, 14970, -3101, 1344, -3101, -3101, + -3101, 255, -3101, 286, -3101, -3101, 43349, -3101, -3101, 72726, + 1270, 1196, -3101, 20210, 20210, 1206, 44262, 60362, 60860, 20210, + 55382, -3101, 20210, 24926, 1212, 20210, 20210, 12350, 20210, 29605, + 60362, 4330, 1191, -3101, 605, 55382, 1230, -3101, 1318, 1318, + 336, 31599, 1523, -3101, 893, 1524, 1453, -3101, 31599, 1453, + 934, 1242, 1536, 1453, -3101, 247, 1545, 1318, 35086, 1251, + -3101, 1318, 1475, -3101, -3101, 20210, 14970, 70307, 1735, -3101, + -3101, -3101, -3101, 1548, 65327, 1268, -3101, -3101, -3101, -3101, + -3101, -3101, 683, 1781, 160, 1784, 20210, 160, 160, 1274, + 195, 195, -3101, 1465, 1276, -3101, 196, 1280, 1284, 1791, + 1798, 154, 122, 1167, 160, 20210, -3101, 195, 1287, 1800, + 1295, 1808, 147, 170, -3101, 198, 20210, 20210, 20210, 1677, + 20210, 10254, -3101, 55382, 1813, 47414, 552, -3101, 174, 1310, + 959, -3101, -3101, -3101, -3101, -3101, -3101, -3101, 1311, -3101, + 179, 6695, -3101, -3101, -3101, -3101, -3101, -3101, 1349, -3101, + -3101, -3101, -3101, 1528, 20210, -3101, -3101, 1312, 1523, -3101, + 199, -3101, -3101, 1523, -3101, -3101, -3101, -3101, -3101, 230, + 1728, 20210, 20210, -3101, 65327, 174, 68315, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, 374, -3101, 401, 45005, 1327, 1321, + 883, 55382, 55382, 1809, -3101, -3101, -3101, -3101, 52394, 172, + 1633, 146, 1466, -3101, -3101, 927, 927, 15494, 1335, 229, + 1123, 16018, 20734, 1687, 1570, 225, 612, 1691, -3101, 1574, + 1801, 24926, 20210, 20210, 623, 891, 20210, 895, 155, -3101, + -3101, -3101, 1625, 55382, 50402, 735, 760, 1346, 1433, 1348, + 211, 1773, -3101, 1350, -3101, 1437, 55382, 72254, 233, -3101, + 1816, 233, 233, 653, 1818, 1441, 279, 1601, 19, -50, + 1350, 3582, -3101, 52394, 269, 116, 1350, 55382, 1448, 595, + 1350, 1772, 65327, 1196, -3101, -3101, 41235, 1354, -3101, -3101, + -3101, 157, 14970, -3101, 1273, 1347, 1371, 467, 202, 1412, + 1432, 14970, 1456, 1577, 178, 1582, 1596, 1598, 1616, 1623, + 1640, 1649, 1652, 168, 1657, 1666, 1674, 1676, 1680, 1690, + -3101, 1692, 181, 1694, 209, 14970, 1702, -3101, 45005, 22, + -3101, -3101, 1706, 184, -3101, 45134, -3101, 1660, 1452, 1457, + 65327, 1405, 55382, 1507, 1055, 1737, 1790, 70790, 1617, -3101, + 1696, 55382, 1618, 3582, 1621, 1374, 1857, 1627, 1085, 1628, + 1387, -3101, 68813, 47414, -3101, -3101, -3101, -3101, -3101, 1761, + 1754, 65327, 47414, 1408, -3101, -3101, 65327, -3101, 55382, 55382, + -3101, 55382, 65327, -3101, 637, 45005, 1915, 754, 72726, 48908, + -3101, -3101, -3101, -3101, 887, 1089, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, 959, 47414, -3101, 1831, 43922, + 1414, 20210, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, 1417, 1757, -3101, -3101, 6573, 1419, 43971, + 1420, 24926, 24926, 174, 1758, -3101, -3101, 24926, 1421, 49406, + 43844, 1423, 1424, 44264, 16542, 20210, 16542, 16542, 44393, -3101, + 1427, 44488, 60362, 1429, 55382, 54386, -3101, -3101, -3101, 20210, + 20210, 4330, 54884, 1471, 31599, -3101, 31599, -3101, 1723, 31599, + -3101, -3101, 3668, -3101, 31599, 1724, 20210, 31599, -3101, 31599, + 1668, 1669, 1435, 31599, -3101, 55382, 1438, 55382, -3101, -3101, + 45005, -3101, 1439, 728, 1434, -3101, -3101, -3101, -3101, -3101, + 1490, -3101, 1490, 1490, -3101, -3101, -3101, -3101, 1442, 1442, + 1444, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, 1447, 1167, -3101, 1490, -3101, 1442, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, 72254, -3101, -3101, + -3101, -3101, -82, 345, -3101, 1449, -3101, -3101, 1460, -3101, + 1446, 1919, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, 1976, 743, 1442, -3101, -3101, 5596, -3101, -3101, 20210, + 20210, -3101, -3101, 1469, 45005, 1495, -3101, -3101, 20210, 20210, + -3101, -3101, -3101, -3101, 1965, -3101, 20210, 1490, 1490, -3101, + 45428, -3101, 39570, 17066, 1553, 1559, 1965, -3101, 1965, -3101, + 45428, 1979, 1979, 37576, -3101, 1638, 44617, -3101, 1481, 328, + 7217, 1477, 1473, -3101, 1482, 1480, -3101, -3101, 41855, 173, + 174, 174, 20210, -3101, 1965, 20210, 45003, 45003, -3101, 191, + 70307, 20210, 20210, 20210, 20210, 20210, 20210, 20210, 20210, 45920, + 1579, 142, 65327, 20210, 20210, 1492, 937, -3101, 20210, 1730, + -3101, 1494, 20210, 1581, 311, 20210, 20210, 20210, 20210, 20210, + 20210, 20210, 20210, 20210, -3101, -3101, 28594, 262, 638, 1835, + 1854, -24, 283, 20210, 1848, 11302, -3101, 1848, -3101, -3101, + -3101, -3101, -3101, 207, -3101, -3101, 1439, 1439, -3101, 65327, + -3101, 55382, 241, 51398, 20210, -3101, -3101, 1500, 1504, 176, + 1572, -3101, -3101, 55382, -3101, 38074, 1814, -3101, 333, 1510, + -3101, 8168, 1767, 1814, 927, -3101, -3101, 25974, 1642, 1812, + 1745, -3101, -3101, 1727, 1729, -3101, 1522, 45298, 21258, 21258, + -3101, 1353, 45005, 1357, -3101, -3101, -3101, -3101, -3101, -3101, + 684, -3101, 55382, 117, 35584, -3101, 1525, 84, -3101, 2203, + 1867, 1829, 1687, 612, 1534, -3101, 55880, 55880, -3101, -3101, + 1698, 1540, 69311, 55382, 1833, 1786, 1836, -56, 70307, -3101, + -3101, -3101, -3101, 55382, 65327, 63848, 69809, 47912, 55382, 47414, + -3101, -3101, -3101, -3101, 55382, 466, 55382, 6859, -3101, -3101, + -3101, -3101, 233, -3101, -3101, -3101, -3101, -3101, 65327, 55382, + -3101, -3101, 233, 65327, 55382, 233, -3101, 1768, 55382, 55382, + 55382, 55382, 2032, 55382, 55382, 959, -3101, -3101, -3101, 21782, + 34, 34, 1763, 12874, 111, -3101, 20210, 20210, 775, 349, + 65327, 1733, -3101, -3101, 750, 1780, 213, -3101, 65327, 1600, + 55382, 55382, 55382, 55382, 55382, 1605, -3101, -3101, -3101, -3101, + -3101, 1558, -3101, 1924, 2074, 1562, 1563, 1930, -3101, 3582, + 1932, 50900, 774, 2226, 1936, 1613, 1941, 13398, 2054, 1820, + -3101, -3101, 1810, -3101, 65327, 2095, -3101, 224, -3101, 47414, + -3101, 232, -3101, 1815, 250, -3101, 14970, 20210, -3101, -3101, + -3101, -3101, -3101, -3101, 1196, 29103, -3101, 756, -3101, -3101, + 2059, 959, 2059, 541, -3101, -3101, 2059, -3101, 2043, 2059, + -3101, 70307, -3101, 7802, -3101, 20210, 20210, -3101, 20210, 1931, + -3101, 2096, 2096, 70307, 24926, 24926, 24926, 24926, 24926, 24926, + 646, 1287, 24926, 24926, 24926, 24926, 24926, 24926, 24926, 24926, + 24926, 26498, 300, -3101, -3101, 762, 2066, 20210, 20210, 1942, + 1931, 20210, -3101, 70307, 1590, -3101, 1595, 1599, 20210, -3101, + 70307, -3101, 55382, 1604, -28, -10, -3101, 1597, 1606, -3101, + 1523, -3101, 844, 868, 55382, 3881, 4941, 6261, -3101, -3101, + 20210, 1935, 3668, 3668, 31599, -3101, 20210, 1607, -3101, -3101, + 31599, 1959, -3101, 3668, -3101, -3101, 36082, 3668, 70307, 767, + -3101, 55382, 70307, 800, 20210, -3101, 14970, 2124, 70307, 2089, + 65327, 65327, 2126, 1615, 1619, 1965, 1700, -3101, 1701, 1704, + 1707, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, 70307, -3101, -3101, 162, -3101, -3101, -3101, -3101, -3101, + -3101, 1622, 1626, 20210, 20210, 74, -3101, 7923, 1630, 1631, + 5776, -3101, 1612, -3101, 1620, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, -3101, 1634, -3101, 1636, -3101, 1641, 1639, 1645, 1644, + 1646, 55382, -3101, 22306, -3101, 65327, -3101, -3101, 20210, 20210, + 55382, -3101, 1677, -3101, 1650, 1653, 40076, -3101, -3101, -3101, + 244, 378, 6592, 283, 3954, 3954, 3954, 45428, -3101, -3101, + -3101, 1667, -3101, 24926, 24926, -3101, 8058, 5129, 10254, -3101, + -3101, 1980, -3101, 940, -3101, 1643, -3101, -3101, 5192, -3101, + 39570, 45381, 20210, 163, -3101, 20210, 1492, 20210, 1741, 3954, + 3954, 3954, 290, 290, 244, 244, 244, 378, 283, -3101, + -3101, -3101, 1656, 20210, 47414, -3101, 1658, 1661, 2022, 1295, + 20210, -3101, -3101, 31599, 1471, 22, 1471, 1965, 45003, -3101, + 895, -3101, 895, -3101, 45005, 55382, -3101, -3101, 1933, 1663, + 31599, 1705, 2142, 2125, 65327, -3101, -3101, 1671, 1848, 1682, + -3101, -3101, 1688, 20210, 1799, 1688, -3101, 1814, 87, 1898, + 1127, 1127, 1353, 1904, -3101, -3101, 1742, -3101, -3101, -3101, + 20210, 13922, 1363, -3101, 1365, -3101, -3101, -3101, -3101, -3101, + 1678, -3101, 1953, -3101, 55382, -3101, -3101, 24926, 2139, 20210, + 36580, 2141, 1938, -3101, -3101, -3101, 1734, 1734, -3101, -3101, + 1770, 1350, 20210, 1934, -3101, 143, 1689, 2055, 341, 2005, + 65327, -3101, 310, 331, -3101, 183, 2061, 250, 2063, 250, + 47414, 47414, 47414, 808, -3101, -3101, -3101, 959, -3101, 243, + 815, -3101, -3101, -3101, -3101, 1795, 807, 1350, 3582, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, 276, 863, 1350, 1811, + -3101, 1817, -3101, 1819, 931, 1350, -3101, -3101, 1552, 8680, + 45005, 579, 111, 111, 111, 14970, -3101, 1939, 1967, 1699, + 45005, 45005, 140, -3101, -3101, -3101, -3101, 1736, -3101, 215, + -3101, 65327, -3101, -3101, -3101, 1733, 1790, 1696, 55382, 3582, + 1744, 2201, 1085, 1387, -3101, 1892, 749, 2466, -3101, 65327, + -3101, 47414, 65327, 55382, 55382, 55382, 64346, -3101, -3101, -3101, + 1747, 1731, -3101, -6, 1971, 1983, 55382, 1796, 55382, 1348, + 2236, 55382, -3101, 836, 17590, 2127, 55382, 1754, -3101, -3101, + -3101, -3101, 65327, -3101, -3101, 45005, -3101, -3101, 20210, 48410, + -3101, -3101, -3101, -3101, -3101, -3101, 47414, -3101, 959, -3101, + 959, 1997, 65327, 42353, 959, 42851, 959, 1760, -3101, 45005, + 40115, 45005, 1942, -3101, 234, 2096, 2901, 2901, 2901, 1332, + 2108, 236, 1764, 2901, 2901, 2901, 258, 258, 234, 234, + 234, 2096, 300, 816, 49406, 1769, -3101, 45005, 45005, -3101, + -3101, 1771, -3101, -3101, -3101, -3101, 1775, 1776, -3101, -3101, + -3101, -3101, -3101, -3101, 65327, 1142, 1471, 246, 246, 246, + 246, -3101, 55382, 55382, 55382, 45005, 2228, 2099, -3101, -3101, + 3668, 45005, 55382, -3101, 27546, -3101, 55382, -3101, 2123, -3101, + 2215, -3101, 55382, 852, -3101, -3101, -3101, 877, 1782, 1619, + 70307, 884, 885, -3101, 1965, 193, 1778, 1472, 1013, 570, + 1359, -3101, 52394, -3101, -3101, 1788, 44781, 20210, -3101, 2156, + -3101, -3101, -3101, 20210, 20210, -3101, 39570, -3101, -3101, -3101, + -3101, 422, 422, 1807, 10254, 44910, -3101, 2103, 40154, 45005, + -3101, 1638, -3101, -3101, 45003, 20210, 514, 2580, 20210, 1822, + 20210, 2146, -3101, -3101, 1802, -3101, -3101, 70307, 20210, 1823, + 5843, 24926, 24926, 5948, -3101, 6858, 20210, 10254, -3101, 41282, + 1803, 1826, 1763, 18114, -3101, 2027, 1827, -3101, 1935, 111, + 1935, 1838, -3101, -3101, -3101, -3101, 5596, -3101, 20210, 1973, + 65327, 124, 2839, 892, -3101, 174, 38074, 1705, 20210, 503, + -3101, -3101, 1834, -3101, 1688, -3101, -3101, -3101, 2041, -3101, + -3101, -3101, 55382, -3101, 1839, -3101, 35584, 2154, 10778, -3101, + 35584, 55382, -3101, -3101, 55382, 40201, 2184, -3101, 65327, 65327, + 65327, -3101, 65327, 1842, 1841, 955, 1843, 372, -3101, 2831, + 955, 2168, 231, 1348, 279, 4532, 480, -3101, -3101, -3101, + 1908, 55382, -3101, 65327, -3101, -3101, -3101, -3101, -3101, 47912, + -3101, -3101, 39071, 47414, -3101, 47414, 55382, 55382, 55382, 55382, + 55382, 55382, 55382, 55382, 55382, 55382, 1196, 20210, -3101, 20210, + 1846, 1847, 1849, 1763, -3101, -3101, -3101, 159, -3101, 1853, + -3101, -3101, -3101, -50, -3101, 215, 1851, 1856, -3101, 50900, + 2662, 1613, 2326, 1790, 869, 64829, -3101, 1858, 1859, 1696, + 913, 933, 3582, 1861, 2339, -3101, 774, 50900, -3101, -3101, + -3101, 2295, -3101, 666, 272, -3101, 1085, -3101, 2662, 1387, + -3101, 2662, 45005, 65327, 1929, -3101, 250, 935, -3101, -3101, + -3101, -3101, -3101, 65327, 1866, -3101, 1866, -3101, -3101, 1866, + -3101, -3101, -3101, -3101, 24926, 2216, 1873, 70307, -3101, -3101, + 55382, -3101, -3101, -3101, 947, 1874, 1935, 55382, 55382, 55382, + 55382, -3101, -3101, -3101, 18638, 20210, 1913, -3101, 1875, 11826, + 2196, -3101, 27022, -3101, -3101, 1879, 36082, 65327, -3101, -3101, + -3101, -3101, 1965, -3101, -3101, 65327, -3101, 1884, -3101, 1885, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, 20210, + 45005, -3101, 45005, -3101, -3101, -3101, -3101, -3101, 7409, -3101, + 1882, 1886, 65327, 20210, -3101, -3101, -3101, 387, 20210, 20210, + 8058, -3101, 6252, 20210, 70307, 961, 8058, 295, 20210, 3314, + 3363, 20210, 20210, 7753, 40240, -3101, 22830, 14446, -3101, 1887, + 20210, 40593, 38572, -3101, 31599, 2099, 1888, 2099, 959, 1890, + 45005, 20210, -3101, -3101, -3101, -3101, 1947, -37, 33093, 2121, + -3101, 1906, 65327, -3101, 1973, 45005, -3101, -3101, 39570, -3101, + -3101, -3101, -3101, -3101, 2356, 2623, 1905, 1909, -3101, 1279, + -3101, -3101, 65327, 1910, -3101, 1911, 955, -3101, 65327, 1943, + -3101, 260, 2219, 100, -3101, 20210, -3101, 2309, 2390, 2831, + 1914, 65327, 55382, 24926, -3101, 656, 203, -3101, 2205, 55382, + 1943, 2345, -3101, -3101, -3101, 372, -3101, 2242, 2157, -3101, + 233, -3101, 20210, 372, 2158, 242, 65327, -3101, -3101, 2902, + -3101, 70307, 250, 250, -3101, 1434, 1917, 1920, 1921, 1922, + 1923, 1926, 1937, 1940, 1948, 1949, -3101, 1950, 1951, 1956, + 1957, 1963, 1964, 1970, 1977, 1447, 1981, -3101, 1982, 1834, + 1984, 1985, 1986, 1987, 1988, 71273, 1990, 1991, 1993, 1998, + 1449, 1999, 887, 1089, -3101, -3101, -3101, -3101, -3101, -3101, + 1165, 2000, -3101, 1945, -3101, -3101, -3101, 2012, -3101, 2017, + -3101, -3101, -3101, -3101, -3101, -3101, 1944, 1946, -3101, -3101, + -3101, 111, 1954, 1966, 65327, 1196, 108, 47414, 65327, 1972, + 1796, 2412, 19162, 768, 2179, 2006, -3101, 959, 2009, -3101, + 1613, -3101, 50900, 3799, 588, 1983, -3101, 320, 1796, -3101, + 2348, 1613, 2019, 2418, -3101, 2176, 65327, 2010, -3101, -3101, + 48410, 1866, 2679, 24926, 70307, 963, 987, -3101, 2490, 2148, + 2099, -3101, -3101, -3101, -3101, -3101, 2011, -9, 2014, 9730, + 2001, -3101, -3101, -3101, -3101, -3101, -3101, 45005, 45005, 65327, + 2197, -3101, -3101, 2013, 2020, 37078, 2473, 2021, -3101, -3101, + 2336, -3101, 30103, -3101, 1619, 2028, 1619, 70307, 1619, -3101, + -3101, 45005, 20210, -3101, -3101, 41321, 2354, 8058, 8058, 6252, + 992, -3101, 8058, 20210, 20210, 8058, 8058, 20210, -3101, 9205, + 587, -3101, 1004, -3101, 40679, -3101, 71756, -3101, -3101, 1913, + 959, 1913, -3101, -3101, 2016, -3101, -3101, -3101, 2085, -3101, + -3101, 1011, 2457, 1973, 20210, -3101, -3101, 2031, 35584, -3101, + -3101, -3101, -3101, 35584, 955, -3101, 2206, 1943, 2033, -3101, + -3101, -3101, -3101, -3101, -3101, 40718, -3101, 61, 20210, -3101, + 150, 1332, -3101, -3101, -3101, -3101, 1943, 1085, -3101, 55382, + 2512, 2402, -3101, -3101, 45005, -3101, -3101, 1965, 1965, -3101, + -3101, 2215, -3101, -3101, 2036, -3101, -3101, 1165, 425, 39071, + 55382, 55382, -3101, -3101, 2038, -3101, -3101, -3101, -3101, -3101, + -50, 2433, 1027, 1028, 774, -3101, 2662, 2662, 45005, 55382, + 2407, 50900, -3101, 47414, 2523, 2047, 55382, 1796, 347, 347, + -3101, 2198, -3101, 2199, -3101, -3101, 2532, 370, -3101, 19686, + 55382, -3101, -3101, 32595, -3101, 2679, 1037, -3101, -3101, 2051, + 2058, -3101, 1913, 20210, 2060, 20210, -3101, 23354, 2536, 2057, + -3101, 20210, 2129, 28070, -3101, 20210, -3101, 55382, 60362, 2065, + 60362, -3101, -3101, -3101, -3101, -3101, 20210, -3101, 8058, 8058, + 8058, 20210, -3101, 20210, -3101, -3101, -3101, 2270, 2197, -3101, + 2197, 20210, 2662, 174, 3989, 65327, -1, -3101, 45005, -3101, + -3101, -3101, 55382, -3101, 47414, -3101, 955, -21, 2067, 20210, + 40757, 2303, -3101, -3101, 2338, -3101, 2398, -3101, 2133, 558, + 2152, -3101, -3101, -3101, -3101, 1196, 959, -3101, 1613, 1983, + 2019, -3101, 2080, 55382, 1038, 2662, 774, 666, -3101, -3101, + -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, -3101, + -3101, 2662, 2524, 2311, 2528, 2662, 45005, 1929, 20210, 99, + -3101, 1039, 2525, -3101, -3101, 2597, 2197, 2091, 23354, 2092, + -3101, 2090, 65327, 45005, 2240, -3101, -3101, 2094, -3101, -3101, + 20210, -3101, 41360, 2097, 2098, 2556, 1763, 2129, 2129, -3101, + -37, -3101, -3101, 2527, 32595, 2484, 1085, 955, 2112, 1047, + -3101, -3101, -3101, -3101, -3101, 3582, -3101, 40843, 2350, 470, + 2331, 2067, 20210, -3101, 2182, -3101, -3101, -3101, 2587, -3101, + -3101, 50900, 2113, -3101, 2019, 1983, 1796, 2019, 2340, -3101, + 2342, -3101, 2114, 41196, 65327, 65327, 1613, 32595, 65327, 2111, + 2129, -3101, 2118, -3101, -3101, -3101, 54386, -3101, 2119, -3101, + -3101, -3101, 20210, 151, -3101, -3101, 2170, 55382, 1054, 64, + 2338, 39071, -3101, 47414, 1222, -21, 2434, -3101, -3101, -3101, + -3101, 186, 2351, -3101, 2353, -3101, 45005, -3101, 2662, 50900, + -3101, -3101, -3101, -3101, -3101, -3101, 32595, 2525, -3101, 333, + -3101, 1471, -3101, 333, -3101, -3101, -3101, -3101, -3101, 1423, + 23878, 23878, 23878, 2128, 2662, -3101, 1471, -3101, 2255, 2331, + -3101, -3101, -3101, -3101, -3101, 164, 164, 2533, -3101, 2193, + -3101, 2019, 1062, 65327, 1688, -3101, 1688, 25450, 2286, 228, + 43883, 2518, -3101, 2518, 2518, -3101, -3101, -3101, 38074, -3101, + -3101, 2643, -3101, 214, -3101, -3101, -3101, 1613, 333, -3101, + -3101, 2633, -3101, -3101, -3101, -3101, -3101, 551, -3101, -3101, + -3101, 1471, 955, -3101, -3101, -3101, 1471, 1688, 24402, 2304, + -3101, 2373, -3101, -3101, -3101, -3101, -3101, -3101, -3101 +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const yytype_int16 yypgoto[] = { - 0, 47, 48, 49, 754, 755, 1838, 1785, 2943, 1228, - 1775, 1352, 756, 2605, 2606, 2607, 2244, 1209, 3372, 2245, - 1210, 1211, 2609, 53, 54, 55, 115, 1240, 757, 758, - 531, 58, 2294, 921, 805, 1094, 807, 1095, 1604, 909, - 1243, 1244, 759, 2647, 2306, 3169, 2696, 3170, 2369, 2300, - 1362, 2362, 1879, 1819, 1363, 539, 1893, 2697, 2652, 1880, - 760, 2594, 2945, 3365, 2620, 3503, 2881, 2882, 3362, 3363, - 2597, 2247, 3431, 3432, 2679, 1766, 3426, 2325, 3305, 2251, - 2232, 2883, 2333, 3264, 2991, 2248, 2863, 2326, 3358, 1854, - 2327, 3359, 3118, 2328, 1816, 1842, 2598, 3433, 2252, 1817, - 2593, 2946, 1754, 2329, 3369, 2330, 550, 2867, 761, 2682, - 1308, 533, 522, 523, 1532, 719, 1284, 720, 762, 939, - 1848, 763, 1301, 1830, 64, 1315, 551, 1851, 764, 1839, - 765, 2666, 2667, 766, 767, 1170, 2548, 2162, 768, 745, - 746, 956, 1332, 747, 70, 1859, 769, 1338, 1339, 964, - 72, 873, 1354, 770, 1355, 1356, 973, 73, 2698, 975, - 976, 74, 75, 772, 3201, 3006, 1317, 1855, 2338, 552, - 773, 2828, 2164, 2551, 3354, 78, 3099, 2167, 1168, 3102, - 3319, 2821, 3097, 2552, 3394, 3448, 3100, 2168, 2169, 3320, - 2170, 774, 80, 822, 1692, 775, 776, 1036, 2018, 777, - 1757, 778, 1096, 86, 87, 1010, 88, 3112, 89, 90, - 1732, 1733, 1734, 851, 863, 864, 2160, 1448, 1962, 856, - 1174, 1701, 838, 839, 2290, 882, 1808, 1696, 1697, 2177, - 2561, 1725, 1726, 1183, 1184, 1950, 3334, 1951, 1952, 1441, - 1442, 3210, 1713, 1717, 1718, 2198, 2188, 1704, 2438, 3029, - 3030, 3031, 3032, 3033, 3034, 3035, 1097, 2735, 3221, 1721, - 1722, 1186, 1187, 1188, 1730, 2208, 92, 93, 2145, 2535, - 2536, 811, 3046, 1465, 1735, 2739, 2740, 2741, 3049, 3050, - 3051, 812, 1005, 1006, 1029, 1024, 1455, 1970, 813, 814, - 1927, 1928, 2407, 1031, 1964, 1980, 1981, 2747, 2460, 1533, - 2233, 1534, 1535, 1995, 1536, 1098, 1537, 1563, 1099, 1568, - 1539, 1100, 1101, 1102, 1542, 1103, 1104, 1105, 1106, 1556, - 1107, 1108, 1580, 1997, 1998, 1999, 2000, 2001, 2002, 2003, - 2004, 2005, 2006, 2007, 2008, 2009, 2010, 1154, 1736, 1110, - 1111, 1112, 1113, 1114, 1115, 1116, 1117, 816, 1118, 1119, - 1653, 2139, 2534, 3039, 3218, 3219, 2812, 3087, 3246, 3345, - 3462, 3490, 3491, 3517, 1120, 1121, 1596, 1597, 1598, 2032, - 2033, 2034, 2035, 2133, 1647, 1648, 1122, 2950, 1650, 2055, - 3042, 3043, 1155, 1434, 1591, 1286, 1287, 1547, 1408, 1409, - 1415, 1902, 1423, 1427, 1932, 1933, 1435, 2101, 1123, 2026, - 2027, 2478, 1558, 1124, 1242, 1603, 2807, 2136, 1651, 2095, - 1131, 1125, 1132, 1127, 1587, 1588, 2495, 2779, 2780, 2065, - 2205, 1680, 2210, 2211, 960, 1128, 1129, 1130, 1288, 526, - 1548, 3449, 1328, 1160, 1289, 2091, 779, 107, 780, 781, - 97, 782, 1150, 860, 1151, 1153, 783, 832, 833, 784, - 845, 846, 1474, 1667, 1475, 869, 102, 103, 1197, 834, - 852, 786, 3196 + -3101, -3101, -3101, 1804, 76, -3101, -3101, 57, -3101, 901, + -3101, 52, -822, 437, -3101, 80, 3788, 2308, 2806, 2700, + -515, -889, -1260, 227, 82, -1151, 8, -3101, -3101, -3101, + -3101, -1491, -582, 118, -3101, -3101, -719, -2512, -675, -3101, + -2979, -3017, -3101, -3101, -817, -2941, -2069, 85, -3101, -3101, + 88, 1, -2089, -3101, -1680, 47, -2106, 91, 92, 821, + -3101, -2574, 94, -887, -1196, -925, -1207, -3101, -209, -3101, + 344, 101, 1401, 1855, -3101, 4, -2186, -2860, -679, -3101, + -782, -3101, -430, -3101, -716, -3101, -812, -718, -757, -2833, + -1152, -3101, 1526, -472, -3101, 490, -3101, -2579, -3101, -3101, + 481, -3101, -1164, -3101, -2216, 44, -700, -2618, -2556, -2185, + -901, 127, -708, 104, -2136, -1107, -3101, 501, -3101, -690, + -3101, -893, -2059, 102, -3101, -3101, 1410, -875, -3101, 103, + 1440, -2143, 10, 17, -3101, -3101, -3101, -3101, -3101, -861, + 431, -1214, -3101, 377, -3101, -3101, -3101, -3101, -266, 106, + -2264, 23, 130, -43, -36, -3101, -31, -3101, -3101, -3101, + 548, -3101, -3101, 14, 50, 1608, -3101, -1044, -3101, -1397, + 709, -3101, 1756, 1765, -2176, -871, -51, -3101, 584, -1671, + -2138, -608, 1025, 1588, 1592, 353, -2950, -3101, -642, -3101, + -168, -3101, -3101, 580, 1072, -1555, -1567, -3101, -2205, -3101, + -554, -438, -3101, -3101, -3101, -3101, -3101, -2504, -2322, -600, + 1051, -3101, 1611, -3101, -3101, -3101, -3101, 33, -1526, 2771, + 633, 45, -3101, -3101, -3101, -3101, 54, -3101, 813, -255, + -3101, 2004, -686, -794, 1824, -581, 141, -1747, -18, 2018, + 402, -3101, -3101, 405, -2095, -1415, 358, -340, 822, -3101, + -3101, -1244, -3101, -1842, -1178, -3101, -3101, -735, -653, -3101, + -3101, -3101, 1686, 1750, -3101, -3101, 2529, 2860, -3101, -897, + 2875, -654, -1030, 1840, -944, 1860, -934, -941, -937, 1863, + 1868, 1872, 1878, 1880, 1881, 1889, -1517, 4753, 734, 833, + -2213, -3101, -2192, 942, 944, 21, -3101, -1402, 205, -3101, + -3101, -3101, -3101, -2699, -3101, -520, -3101, -509, -3101, -3101, + -3101, -1726, -3100, -1748, -3101, 2281, 759, -3101, -3101, 346, + -3101, -3101, -3101, -3101, -1546, -3101, 5254, 649, -3101, -2014, + -3101, -3101, -969, -829, -1156, -993, -1231, -1928, -3101, -3101, + -3101, -3101, -3101, -3101, -1205, -1773, -241, 716, -3101, -3101, + 809, -3101, -3101, -3101, -1734, -2109, -3101, -3101, -3101, 720, + 1403, 39, -836, -1613, -3101, 783, -2390, -3101, -3101, 360, + -3101, -621, -1125, -2439, 1221, 67, -3101, 2775, -2534, -3101, + -3101, -734, -2650, -1126, -892, -3101, 112, -3101, 317, 131, + -1678, -3101, 6, -3101, -453, -3101, -3101, -2584, -3101, 132, + 134, 2100, -3101, 1058, -3101, -3101, -3101, -3101, -609, -3101, + -619, -624, -3101, -3101, 28, -898, 1531, -3101, 135, 392, + -3101, 888, -3101, 616, 136, -3101, 1989, -463, 137, 1201, + -3101, -3101, -3101, 18, -579, 319, -3101, 1204, -3101, -3101, + 1648, 596, 139, -3101, 339, 15, -3101, -3101, -3101, 77, + 2789, 144, 7, -2954, 145, -2653, -1675, -7, -3101, -3101, + -3101, -722, -3101, -2522 }; -/* 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. */ +/* 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 -2061 static const yytype_int16 yytable[] = { - 521, 1227, 85, 868, 91, 60, 65, 908, 76, 718, - 59, 104, 884, 885, 84, 101, 521, 717, 68, 77, - 883, 1126, 85, 854, 91, 808, 95, 1193, 524, 1025, - 525, 1800, 1156, 957, 1789, 785, 1245, 2180, 971, 85, - 1929, 1426, 1296, 1681, 815, 1476, 525, 1351, 867, 1298, - 1772, 850, 1753, 887, 1788, 1582, 771, 888, 809, 1400, - 1335, 2054, 2143, 2017, 1399, 1805, 1398, 2566, 1396, 1683, - 1759, 2554, 2282, 744, 1763, 1984, 1341, 2599, 2078, 2079, - 50, 1835, 521, 521, 51, 2691, 52, 56, 1357, 2977, - 817, 808, 808, 886, 2456, 57, 901, 866, 1793, 61, - 2592, 1861, 62, 1657, 2518, 85, 63, 66, 1660, 847, - 815, 815, 525, 525, 2553, 972, 2979, 893, 2951, 2995, - 67, 2948, 69, 71, 809, 809, 79, 81, 82, 2537, - 1245, 2539, 2992, 83, 94, 96, 98, 1594, 1007, 99, - 2778, 100, 959, 1028, 967, 2653, -368, 2458, 2639, 2640, - 2641, 2842, -1330, 1365, 1048, 2847, 817, 817, -1905, -1905, - -514, 2203, 2314, -852, 2307, 2311, -2045, -2045, 2200, 2439, - 2660, 1229, 1546, 1233, 1329, 1237, 819, -518, 1559, 1560, - 2147, 3393, 2448, 977, -860, 536, -860, -857, 1329, 2668, - -1271, -857, 819, 2661, 2656, 1572, 1048, -1252, -1268, -1268, - -1271, 1410, -1896, 2410, -1913, -1896, -1272, -1913, 1664, 3188, - -2036, -2036, -2054, -2054, -1269, -1269, -1272, 2093, 1906, 948, - 3173, -2031, -2031, 1908, -819, -832, -847, 819, 819, 1744, - 1755, 2093, 3122, 1138, 3267, 2600, 1182, 3192, -2056, -2056, - -468, 1791, 2703, 2705, 1345, 2708, 1755, 2476, -1109, 1048, - 1613, 3528, 2742, 1329, 819, 1615, -1109, 2627, 1803, 1590, - -514, 971, 858, 1661, 1345, 819, -229, 1804, 2130, 1048, - 1245, -229, 874, -1130, 1666, 1048, 2131, -518, 3474, 1320, - 3280, -1130, 1143, 1185, 878, 1623, 1773, 1688, 3105, 1776, - 1777, -651, 2743, 1002, 3157, 2675, 874, 14, 15, 3137, - 1145, 1613, 537, 1690, 3466, 1614, 1615, 3352, 880, 1613, - 1764, 2422, 2971, 1614, 1615, 1028, 3379, 2996, 1321, 1625, - 3088, 1449, 3090, 1946, 1747, 2288, 1564, 1007, 3529, 2420, - 1008, 3, 4, 1764, 3133, 2814, 1623, 2816, 2391, 2595, - 1142, -789, 1574, 23, 1623, 108, 2601, 3397, 1906, 880, - 3459, 1546, 1907, 1908, 1946, 879, 1990, 1778, 2714, 2213, - 1685, 3417, 2175, 875, 3523, 2140, 1741, 2423, 3213, 1359, - 1625, 3510, 2114, 2856, 1737, 1738, 3119, 1662, 1625, 2648, - 3360, 819, 113, 2230, 1538, 3297, 2885, 875, 2206, 1463, - 3512, 3452, 2080, 2603, 2230, 1783, 836, 105, 3095, 1702, - 2023, 3189, 787, 2815, 2529, 3131, 3413, 3414, 2865, 2029, - 3439, 2725, 3535, 3442, 906, 1577, 3190, 2383, 907, 1784, - 3530, 3183, 2835, 2898, 2304, 1906, 1807, 3296, 1845, 1907, - 1908, 3156, 2855, 880, 2866, 3310, 3096, 1578, 1787, 1546, - 3298, 1464, 3361, 2231, 3182, 3311, 106, 2176, 2411, 3299, - -514, 3120, 2838, 3481, 2589, 3194, 2592, 1014, 2592, 3454, - 2886, 1794, 1298, 2433, 2434, 2435, 114, -518, 1146, 1009, - 1147, 1330, 3482, 3300, 3004, 2596, 3507, -789, 2773, 1501, - 3132, 2392, 3467, 2997, 1749, 1330, 26, 27, 28, 2836, - 2289, 2393, 1139, 1015, -671, 3134, 2115, 1322, 837, 3278, - 1582, 1663, 1779, 1204, 3378, 2207, 3460, 1703, 3505, 1450, - 2424, 2715, 1780, 2116, 2141, 109, 1765, 1576, 2117, 1017, - 1764, -514, 1686, 3019, 1762, 3211, 110, 3524, 2421, 2296, - 2234, 949, 1873, 1806, 3353, 3461, 3262, 1048, -518, 1765, - 85, 3499, 3469, 3000, 2887, 558, 3301, 1739, 3513, 2742, - 1330, 749, 923, 33, 2988, 3272, 2118, 3256, 534, 3302, - 3268, 111, 824, 1538, 35, 1676, 2602, 1140, 2603, 3002, - 3186, 3010, 3123, 3168, 1987, 3531, 865, 865, 2972, 1792, - 1042, 1602, 1762, 2025, 881, 718, 37, 2452, 2094, 2743, - 38, 2287, 1684, 945, 1740, 2628, 2225, 2054, 2604, 1691, - 3440, 1938, 2520, 1750, 876, 1762, 859, 3191, 1559, 1560, - 3475, 112, 3312, 1323, 957, 821, 906, -1109, 2541, 1863, - 907, 2794, 3187, 40, 1555, 1867, 3441, 1953, 2471, 971, - 2569, 3287, 1331, 1572, 43, 2214, 2351, 2132, 2200, -514, - 788, 897, -1130, 1973, 2736, 1789, 1334, 538, 1021, 1764, - 44, 1538, -2027, -2027, 2712, 2951, -518, 1546, 2948, 2662, - 1577, 2757, 1577, 1295, 2671, 2564, -368, 1451, 2357, 2146, - -1905, -1905, -1330, 2378, 45, -852, 1569, 1569, -514, 2690, - -514, 3259, 1578, 2305, 1578, 2384, 3260, 1343, 46, 2556, - 1344, 1172, 3113, 2036, 2037, -518, 1579, -518, 1581, -857, - 2653, 3247, -1271, 3249, 1608, 905, 972, 906, 3233, -1252, - 868, 907, -1271, 2119, -1896, 2412, -1913, -1896, -1272, -1913, - 1923, 3177, 2417, 2022, 1590, 1561, 1765, 999, -1272, 1864, - 1245, 2074, 1245, 1590, 3384, 1871, 1562, 1567, -847, 1658, - 2148, 1783, 996, 3377, 1382, 1383, 970, 2057, 1349, 1350, - 1546, 3500, 1646, 3383, 85, 867, 91, 1613, 2449, 1564, - 3303, 868, 2449, 3304, 1148, 1784, 1944, 785, 1349, 1350, - -229, -229, 2287, 2823, 3146, 3147, 2075, 1797, 1699, 1574, - 3104, 1178, 2649, 2650, 1452, 1755, 521, 1705, 818, 974, - 1459, 2470, 1762, 1173, 2158, 985, 1756, 521, 1641, 1642, - 1643, 1644, 1645, 1646, 935, 925, 997, 926, 1643, 1644, - 1645, 1646, 2977, 887, 815, 2013, 525, 888, 3427, 2159, - 1194, 3014, -2030, -2030, 3325, 815, 1625, 525, 2824, 2418, - 3106, 521, 521, 1706, 3139, 3163, -2028, -2028, 3501, 998, - 1033, 1144, 3144, 936, 2869, 3171, 2260, 1920, 1921, 1922, - 1923, 1034, 3450, 886, 521, 1765, 2263, 1180, 2341, 2266, - 817, 1144, 1674, 1388, 1389, 1675, 2418, 3502, 855, 1538, - 3183, 817, 2258, 85, 540, 91, 60, 65, 2664, 76, - 2621, 59, 104, 1178, 1613, 84, 101, 2872, 1546, 68, - 77, 23, 906, 2622, -1252, 1149, 907, 95, 3069, 521, - 718, 1707, 861, 1283, 521, 1602, 2965, 3053, 2966, 2530, - 3055, 870, 3057, 2096, 1157, 847, 847, 2951, 847, 1623, - 2948, 1762, 1918, 1919, 1920, 1921, 1922, 1923, 938, 1764, - 2427, 1755, 1446, 2726, 2727, 2728, 2729, 541, 3315, 1456, - 871, 819, 1758, 2283, 2284, 2285, 2492, 1214, 2317, 2361, - 872, 50, 1708, 1625, 3428, 51, 1283, 52, 56, 1180, - 3265, 2350, 1538, 3525, 877, 2352, 57, 1215, 2354, 970, - 61, 2054, 2785, 62, 521, 521, 983, 63, 66, 85, - 521, 91, 1341, 521, 521, 1299, 521, 521, 521, 521, - 2363, 67, 785, 69, 71, 1705, 2859, 79, 81, 82, - -2029, -2029, 521, 3252, 83, 94, 96, 98, 1181, 521, - 99, 808, 100, 1216, 1709, 2222, 2371, 1875, 808, 1178, - 2375, 1929, 1048, 2377, 1179, 889, 521, 1283, 1531, 1764, - 815, 1546, 525, 2825, 26, 27, 28, 815, 904, 525, - 3429, 1706, 2259, 1546, 809, 3270, 868, 521, 819, 2372, - 2876, 809, 1554, 23, 2373, 2542, 1449, 2626, 2543, 2017, - 1868, 2102, 2269, 1869, 1566, 1789, 521, 2276, 2102, 2261, - 3346, 2642, 3347, 1546, 2264, 3079, 817, 521, 521, 521, - 1546, 521, 521, 817, 2860, 2567, 718, 943, 23, 2103, - 1048, 1592, 1577, 2575, 1600, 1180, 2103, 2637, 933, 2877, - 1538, 33, -1905, 2234, 3356, 1947, 933, 2564, 2638, 1217, - 1948, 3241, 2416, 2374, 1578, 521, 1546, 2878, 3205, 545, - 1546, 966, 3242, 1577, 1764, 906, 1546, 2134, 1579, 1601, - 910, 2135, 521, 521, 2629, 1765, 1693, 1694, 38, 1700, - 888, 888, 922, 888, 1181, 1578, 3279, 549, 3399, 1546, - 2861, 1144, 2862, 1862, 927, 3373, 928, 2630, 1218, 1581, - 1708, 1201, 1862, 971, 1037, 1038, 1039, 1202, 1219, 521, - 934, 40, 1443, 521, 521, 929, 886, 886, 934, 886, - 1220, -209, 43, 521, 521, 521, 940, 1457, 521, 1594, - 1467, 1462, 1014, 941, 1471, 2474, 26, 27, 28, 2676, - 1986, 1762, 2510, 1987, 2104, 2684, 1553, 1531, 46, 2105, - 2011, 2104, 1221, 2012, 2106, 1790, 2293, 2428, 2879, 2429, - 2826, 2106, 1709, 1937, 946, 1939, 1940, 2880, 1015, 1821, - 2511, 26, 27, 28, 1047, 1765, 46, 1906, 2752, 947, - 1283, 1907, 1908, 1538, 1458, 1909, 1910, 1911, 950, 1283, - 1133, 1134, 2634, 1136, 1017, 1538, 2301, 2366, 1201, 2302, - 2367, 951, 2787, 33, 1202, 2331, 1223, 2332, 1822, 935, - 2508, 952, 1203, 1283, 1881, 2404, 2038, 1821, 2405, 962, - 2614, 953, 2616, 2039, 2040, 1538, 2538, 2041, 2042, 2043, - 2450, 1224, 1538, 2451, 2453, 1531, 2617, 2451, 33, 2618, - 38, 1762, 2852, 3178, 2854, 963, 1829, 1831, 936, 1832, - 1226, 718, 1833, 983, 2623, 2687, 1822, 2624, 1987, 1856, - 718, 1882, 2749, 2054, 3015, 2451, 2737, 981, 1538, 2744, - 1765, -595, 1538, 40, 982, 38, -595, 970, 1538, 2611, - 3521, 2613, 1883, 937, 43, 85, 2750, 91, 984, 2012, - 2512, 1823, 987, 1824, 718, 2513, 1570, 1571, 785, 521, - 1884, 1538, 1878, 2753, 1885, 990, 2754, 2107, 40, 1203, - 3508, 991, 3509, 1965, 2107, 992, 1967, 979, 2108, 43, - 974, 1971, 993, 1021, 1974, 2108, 994, 1886, 2755, 1978, - 1887, 2754, 995, 938, 865, 44, 1762, 2578, 46, 996, - 2949, 1824, 1451, 2430, 1035, 2431, 1888, -595, 1032, 521, - 521, 2896, 1175, 3534, 1177, 521, 1001, 521, 2830, 45, - 1030, 2831, 521, 521, 521, 521, 2964, 540, 1040, 1204, - 2659, 2889, 1135, 2827, 3484, -2032, -2032, 521, 521, 2853, - 1041, 2987, 1043, 521, 2302, 815, 521, 525, 1913, 3496, - 1042, 521, 808, 521, 521, 808, -595, -2033, -2033, 521, - 808, 1546, 1137, 808, 2774, 2775, 3003, 821, 808, 2367, - 2888, 815, 2897, 525, 815, 540, 525, -2034, -2034, 815, - 2974, 525, 815, 3008, 525, 809, 3009, 815, 809, 525, - 541, 817, 1206, 809, 3016, 1214, 809, 3017, 1141, 1889, - -1316, 809, 3070, 3206, 3532, 2012, 2012, 1890, 2514, 3533, - 3342, 3207, 3343, 1531, 2451, 1215, 1152, 817, 1914, 2515, - 817, -2035, -2035, 1158, 1207, 817, 1204, 1159, 817, 1891, - 1590, 1166, 3236, 817, 3243, 2012, 3253, 1987, 541, 3254, - 1161, 1594, 2763, 2765, 2766, 521, 521, 2762, 2764, 2761, - 2760, 85, 1167, 91, 521, 521, -2037, -2037, 1892, 2014, - 2563, 1216, 521, 2019, 2021, 1162, 1353, 2015, 2016, 521, - 3286, -2038, -2038, 2302, 1394, 2020, 3290, 1163, 3322, 2367, - 1612, 2012, 1176, 1613, 878, 1205, 1195, 1614, 1615, 1206, - 3390, 1196, 2316, 2367, 718, 1208, 1546, 3395, 521, -596, - 3396, 521, 3421, 1198, -596, 3422, 1531, 521, 521, 521, - 521, 521, 521, 521, 521, 718, -2039, -2039, 1623, 521, - 521, 1207, 1297, 2090, 521, -2058, 3465, 1199, 521, 3396, - 2100, 521, 521, 521, 521, 521, 521, 521, 521, 521, - 3506, 2695, 521, 3396, 2564, 971, -2040, -2040, 1200, 521, - 116, 1283, 1625, 1546, 535, 879, 2143, 1217, -2041, -2041, - -2042, -2042, 748, 2182, -2043, -2043, 1212, 888, -2044, -2044, - 521, 1213, 545, 1538, 966, -596, 835, -2046, -2046, 3150, - 848, 1230, 2074, -2047, -2047, -2048, -2048, 1234, 1606, 1238, - 865, 1291, 1208, -2049, -2049, 1201, 1239, 521, 1609, 1294, - 549, 1202, 3114, 886, 1295, 2896, 1218, 1300, 521, 521, - 1303, 1149, -2050, -2050, -2051, -2051, 1219, 2507, 1659, 1302, - 545, 1316, 966, 1201, -596, -2053, -2053, 1665, 1220, 1202, - 1915, 1916, 1917, 880, 1918, 1919, 1920, 1921, 1922, 1923, - 1318, 1201, -2055, -2055, 1531, 548, 1326, 1202, 549, -2058, - 1374, 1375, 1319, 718, 1327, 718, -2057, -2057, 1546, 1333, - 1221, 2246, 2846, 2250, 1336, 3167, -2058, 1809, 1810, 1337, - 1990, -2058, 2044, 2045, 2046, 1360, 2047, 2048, 2049, 2050, - 2051, 2052, 2970, 2982, 2201, 2202, 1342, 3483, -646, -646, - 1361, 3485, -650, -650, 1366, 521, 3007, 540, 1424, 1283, - 1540, 2998, 521, 521, -649, -649, 1203, 1437, 1538, -2058, - 1384, 1385, 1388, 1389, 1223, 3110, 3111, 3081, 3321, 1439, - 1382, 1383, 2558, 2559, 3492, 3493, 3518, 3519, 1669, 1670, - 1440, 1447, 1454, 1453, 1203, 3232, 2319, 1460, 1461, 1224, - 1283, 1466, 1470, 1472, 1549, 85, 3526, 1552, -823, 1561, - 1550, 1565, 1203, 1546, -830, 718, 46, 2335, 1226, -671, - 541, -820, 1283, 521, 1634, 1538, 1865, -672, 1866, -821, - 1201, 970, 1575, -824, 1576, -822, 1202, 1201, 1586, 1605, - 1599, 1607, 1652, 1202, 881, 1654, 1656, 1531, 1668, 2440, - 1677, 521, 521, 1678, 521, 2443, 1687, 1682, 1689, 1531, - 521, 521, 521, 521, 521, 521, 2564, 1179, 521, 521, - 521, 521, 521, 521, 521, 521, 521, 521, 1181, 1727, - 1729, 1731, 1742, 521, 521, 1760, 1761, 521, 1762, 1531, - 1546, 14, 15, 543, 521, 1767, 1531, 2949, 1768, 1388, - 1389, 1769, 1774, 1781, 1782, 1796, 113, 1786, 1802, 1812, - 1877, 1813, 1814, 1818, 1826, 1827, 521, 1837, 1828, 521, - 3142, 521, 1840, 1204, 1841, 521, -2058, 1843, 808, 3321, - 1538, 1844, 1531, 3471, 808, 1846, 1531, 23, 521, 1540, - 1283, 1203, 1531, 1847, 1849, 1850, 1857, 815, 1203, 525, - 1858, 1204, 1297, 815, 1862, 525, 1870, 3284, 1895, -208, - 1897, 809, 3151, 3152, 1541, 1531, 1900, 809, 1898, 1204, - 1903, 1926, 3321, 1966, 1945, 1934, 1935, 521, 521, 1942, - 1963, 1972, 1231, 1975, 1976, 1985, 1206, 1994, 1977, 1982, - 1555, 2025, 1562, 817, 3052, 1988, 1993, 1546, 1048, 817, - 2064, 1567, 545, 1613, 546, 1989, 2058, 1991, 1992, 2059, - 1235, 2024, 2067, 2092, 1206, 2110, 868, 521, 1232, 2069, - 2070, 3321, 521, 521, 2072, 1538, 2071, 1540, 2221, 2099, - 549, 1546, 1206, -2058, 911, 3375, 1594, 2111, 2137, 2113, - 1641, 1642, 1643, 1644, 1645, 1646, 1236, 521, 521, 1011, - 2144, 2138, 521, 2161, 1012, 2157, 2156, 879, 2181, 2178, - 912, 1592, 2190, 2191, 1207, 1047, 521, 2192, 1906, 521, - 3337, 521, 1907, 1908, 2193, 2194, -2058, -2058, -2058, 2100, - 26, 27, 28, 2195, 2216, 2212, 2217, 521, 718, 1208, - 2227, 2229, 2299, 2220, 521, 2527, 1047, 521, 1204, 1906, - 2223, 2228, 1538, 1907, 1908, 1204, 808, 1909, 1910, 1911, - 1546, 880, 2308, 1013, 521, 2303, 2318, 1208, 3128, 2320, - 2321, 2322, 2336, 808, 2339, 815, 913, 525, 2337, 2342, - 2343, 521, 2344, 2346, 2345, 1208, 2347, 2349, 2353, 809, - 2368, 2376, 815, 1541, 525, 1931, 1906, 33, 521, 521, - 2406, 1930, 2413, 1546, 2425, 914, 809, 2267, 35, 2949, - 2437, 1206, 2414, 2444, 2274, 521, 2415, 521, 1206, 2419, - 2426, 817, 2442, 2455, 2462, 2457, 521, 2463, 2464, 2483, - 37, 2466, 2467, 2468, 38, 1014, 2469, 2485, 817, 2472, - 1789, 2480, 2473, 2268, 718, 718, 718, 2481, 915, 1358, - 2275, 2484, 2246, 2246, 2246, 2488, 2486, 540, 2489, 1538, - 2487, 2490, 2491, 2501, 3273, 2502, 2149, 40, 2504, 2509, - 2525, 1015, 1612, 2516, 2526, 1613, 2531, 2532, 43, 1614, - 1615, 1541, -1316, 521, 2533, 868, 2544, 1016, 2226, 1283, - 2172, 2174, 2545, 1538, 44, 1540, 2547, 1017, 2235, 2549, - 2238, 2550, 2555, 2249, 971, 1546, 1691, -652, 2570, 2253, - 1623, 2255, 2560, 2557, 1208, 2574, 2571, -2058, 45, 2577, - 541, 1208, 1829, 1831, 2262, 1832, 2581, 1531, 1833, 2265, - 867, 1018, 46, 2270, 2271, 2272, 2273, 1912, 2277, 2278, - 2573, 2582, 2583, 2585, 1625, 521, 2587, 2588, 718, 2591, - 2610, 2612, 1192, 2625, 2631, 2632, 1878, 2633, 2643, 2644, - 1913, 2645, 521, 970, 2646, 2658, 2657, 2663, 2673, 2677, - 718, 2681, 1538, 2685, 965, 916, 2674, 1019, 1878, 2678, - 2692, 1610, 2702, 2713, 1020, 2733, 917, 2710, 1540, 2720, - 2074, 2721, 2716, 3326, 2734, 3328, 2719, 2745, 2279, 1914, - 2722, 2746, 2751, 2759, 2770, 2782, 2767, 2792, 521, 2517, - 1358, 2295, 2295, 2776, 2793, 1538, 2806, 3336, 2790, 2796, - 2811, 918, 2817, 2837, 2813, 2820, 1021, 2839, 2841, 2805, - 1914, 2843, 2851, 2857, 2884, 2858, 815, 2864, 525, 2900, - 2973, -2058, 2980, 2967, 919, 1022, 2976, 521, 2968, 2969, - 2981, 2989, 544, 3338, 2985, 3340, 2986, 2990, -2058, 2994, - 868, 3005, 1531, -2058, 2302, 3012, 1144, 3013, 3038, 3458, - 3018, 920, 3040, 3044, 2808, 3048, 3423, 3058, 1353, 521, - 3059, 3061, 817, 3419, 2370, 521, 521, 3062, 1358, 3082, - 3089, 1358, 1358, 868, 3092, 3412, 521, 3101, 3094, 1541, - 3103, -2058, 545, 3107, 966, 1592, 3108, 521, 3121, 3109, - 521, 3117, 521, 3115, 1023, 3125, 3126, 1538, 3116, 1531, - 521, 547, 3127, 521, 521, 3135, 1540, 548, 521, 521, - 549, 3138, 3407, 3140, 3141, 521, 3145, 3158, 1592, 3159, - -2026, 3160, 3174, -2027, -2028, -2029, 2845, 3179, 3193, -2030, - 521, 3197, -2031, 3161, 3162, 3199, 1634, 85, 3164, 91, - 521, 3180, -2032, 85, -2033, 2014, -2034, 1546, -2035, 2019, - 2021, 520, 532, 2015, 2016, 2829, -2037, 556, 3195, -2038, - -2039, 2020, 521, 556, -2040, -2041, -2042, 806, -2043, 820, - 3165, 2844, 1541, 823, 556, 831, 3208, -2044, 831, -2046, - 3172, 849, 853, -2047, -2048, 853, -2049, -2050, 556, 556, - -2051, -2058, -2058, -2058, -2052, 1918, 1919, 1920, 1921, 1922, - 1923, 718, 1874, 1876, 2947, 718, 3216, 718, -2053, 2246, - -2054, -2055, -2056, 2952, -2057, 2250, -1269, 3198, 3202, 521, - 3209, 521, 1915, 1916, 1917, 3212, 1918, 1919, 1920, 1921, - 1922, 1923, 3214, 806, 806, 3220, 3226, 3228, -2058, 3223, - 3227, 3222, 3235, 1011, 3231, 3250, 3251, 849, 1012, 1540, - 85, 3255, 853, 556, 853, 853, 853, 1829, 1831, 11, - 1832, 1540, 2978, 1833, 3258, 3261, 3263, 3275, 3276, -1268, - 3283, 3447, 3285, 3292, 3293, 3294, 3307, 85, 1865, 3308, - 85, 3309, 3330, 3331, 3324, 868, 3323, 14, 15, 2999, - 3327, 1540, 3001, 3339, 3333, 3344, 521, 3364, 1540, 1531, - 3134, 3368, 3370, 3371, 3374, 3386, 3380, 1013, 3387, 3388, - 1541, 3398, 3393, 3400, 3402, 3085, 521, 521, 3405, 3409, - 3406, 521, 3410, 3411, 521, 3418, 1446, 3420, 3425, 3416, - 1592, 3430, 3436, 23, 1540, 3437, 3438, 3443, 1540, 3444, - 3445, 3463, 3453, 3455, 1540, -2058, 3457, 3473, 3476, 3478, - 3494, 521, 1641, 1642, 1643, 1644, 1645, 1646, 3497, 1538, - 3474, 3511, 3475, 3516, 3522, 521, 3527, 1540, 3536, 3537, - 521, 521, 3148, 2254, 868, 521, 1531, 2608, 1164, 1014, - 521, 2903, 2153, 521, 521, 1798, 2899, 1189, 521, 1283, - 2635, 2297, 521, 2654, 2699, 908, 521, -527, 3203, 3434, - 3504, 2975, 3271, 521, 3472, 808, 3479, 3306, 3498, 980, - 2590, 2615, -527, 1752, 3470, 1015, 2868, -527, 3477, 867, - 2030, 2586, 3468, 2993, 815, 2694, 525, 2953, 2619, 1825, - 2355, 1016, 2060, 2833, 2061, 3391, 1872, 3351, 809, 3451, - 2832, 1017, 3415, 1860, -527, 3520, 1171, 521, 2869, 2818, - 2576, 1444, 1679, 1541, 2870, 521, 2680, 2219, 1445, -527, - 2076, 2562, 2724, 1723, -527, 1541, 1724, 2871, -527, 3456, - 817, 1543, 2572, 2187, 521, 1018, 26, 27, 28, 3401, - 2651, 3329, 2218, 1531, 810, 2546, 2447, 3230, -527, 2718, - 1728, 2872, 3047, 2873, 2717, 1541, 1190, 986, 2665, 2748, - 1000, 3277, 1541, 2461, -1788, 1411, 1395, 2364, 1397, 1401, - 1402, 1403, 1404, 1405, 2365, -527, 3404, 2947, 3403, 1406, - 1407, 1019, 2499, 2772, 2565, 2523, 2477, 3093, 1020, 2521, - 2500, 2784, 2152, 2454, 1954, -527, 894, -527, 1541, 0, - 1353, 0, 1541, 33, 0, 0, -527, 0, 1541, 2700, - 0, 2701, 0, 0, 35, 2706, 0, 2709, 0, 0, - 0, 0, 0, 521, 718, 0, 0, 0, 2199, 2199, - 1021, 1541, 1878, 0, 0, 868, 37, 0, 0, 0, - 38, 2874, 85, 0, -527, 0, 0, 0, 0, 1022, - 0, 0, 970, -527, 3185, 521, 1531, 0, 0, 0, - 39, 0, 0, 0, -1788, 0, 0, 0, 0, 0, - 0, 521, 0, 40, 0, 0, 0, 0, 1047, 0, - 1592, 1906, 0, 0, 43, 1907, 1908, 0, 1358, 1909, - 1910, 1911, 0, 0, 0, 0, 0, 0, 1358, 1531, - 44, 1358, 0, 0, 521, 0, 0, 0, 0, 2875, - 1543, -1788, 0, 0, 2876, 521, 521, 0, 1023, 521, - 0, 521, 0, 1191, 45, 0, -1788, 0, 0, 0, - 0, -1788, 0, 0, 1544, 0, -1788, 0, 46, 1540, - 0, 0, 0, 853, 0, -1788, 521, 0, 853, 0, - -1788, 853, 0, 0, 0, 0, 0, -527, 1545, 556, - 0, 0, 0, 2877, 2848, 2849, 1047, 0, 0, 1906, - 521, 0, 0, 1907, 1908, 0, 0, 1909, 1910, 1911, - 0, 2878, -1788, 0, 0, 0, 0, 0, 0, 0, - 0, 1358, 2901, 0, 2788, 0, 0, 0, 1543, 0, - 0, 2947, -1788, 0, -527, 0, 0, 2954, 2955, 2956, - 2957, 2958, 2959, 2960, 2961, 2962, 2963, 0, 0, 0, - 0, 0, 0, 0, 0, 906, 85, 85, 1161, 907, - 0, 0, 0, 0, 1421, 0, 0, 0, 3288, 3289, - 521, 718, 0, 0, 0, 521, 0, 0, 0, 1878, - 0, -1788, 0, 0, -1788, 521, 0, 521, 0, 521, - -1788, 2944, 0, 521, 0, 521, 0, 521, 0, 2215, - 0, 0, 906, 815, 1540, 525, 907, 0, 521, 0, - 0, 0, 2879, 521, 0, 521, 0, 0, 0, 0, - 0, 2880, 1913, 521, 2651, 0, 0, 0, 0, 0, - -1788, 0, 0, 85, 0, 85, 718, 0, 0, 2465, - 0, 521, 0, 1544, 3357, 3348, 0, 3350, 0, 817, - 0, 1612, 0, 0, 1613, -1788, 0, 0, 1614, 1615, - 0, 1540, 0, 0, 0, 0, 0, 1545, 1214, 0, - 0, 0, 0, 1541, 0, 85, 0, 0, 0, 955, - 556, 556, 0, 0, 0, 0, 0, 3382, 1215, 1623, - 521, 85, 1914, 0, 0, 85, -2058, 0, 0, 0, - 521, 0, 0, 3385, 0, 0, 0, 3389, 0, 0, - 1913, 0, 521, 855, 0, 1419, 0, 0, 0, 0, - 0, 978, 532, 1625, 0, 0, 521, 520, 0, 853, - 1011, 1544, 0, 0, 1216, 1012, 0, 0, 806, 0, - 0, -1788, 1004, 1004, 521, 0, 1543, 1004, 1027, 0, - 0, -1788, 0, 0, 815, 1545, 525, 0, 0, 0, - 831, 831, 831, 1421, 0, 0, 1540, 0, 0, 521, - -1788, 0, -1788, -1788, 831, 831, 0, 831, 0, 0, - 1914, 0, 0, 3129, 521, 0, 0, 3091, 2797, 0, - 853, 2540, 0, 2947, 1013, 718, 556, 815, 0, 525, - 817, 0, 0, 3357, 2892, 0, 0, 853, 1541, -1788, - 853, 820, -1788, -1788, -1788, 0, 0, 0, 521, 85, - -2058, 0, 0, 0, 0, 0, 0, 0, 2568, 2568, - 1217, 3480, 521, 521, 521, 0, 0, -2058, 0, 1543, - 0, 0, -2058, 817, 0, 85, 815, 0, 525, 0, - 0, 0, 0, 0, 0, 853, 1293, 3495, 0, 521, - 0, 1540, 0, 0, 0, 1541, 1014, 0, 0, 0, - 853, 853, 853, 853, 1314, 0, 0, 0, 1214, 1218, - -2058, 0, 0, 0, 0, 0, 0, 1325, 0, 1219, - 0, 0, 817, 0, 0, 0, 0, 0, 1215, 0, - 521, 1220, 1015, 0, 1915, 1916, 1917, 0, 1918, 1919, - 1920, 1921, 1922, 1923, 0, 0, 0, 0, 1016, 1004, - 1027, 0, 853, 0, 0, 1418, 0, 0, 1017, 0, - 0, 1004, 1004, 1221, 0, 1634, 0, 556, 1540, 0, - 0, 0, 0, 806, 1216, 2890, 0, 0, 0, 1544, - 806, 0, 0, 0, 0, 2891, 3181, 0, 0, 0, - 556, 0, 1018, 0, 0, 23, 0, 0, 0, 0, - 1541, 0, 0, 1545, 557, 0, 1551, 1543, 0, 1353, - 557, 0, 0, 1968, 0, 0, 0, 1223, 0, 1421, - 1421, 557, 1915, 1916, 1917, 1421, 1918, 1919, 1920, 1921, - 1922, 1923, 0, 0, 0, 557, 557, 0, 1019, 0, - 0, 0, 1224, 0, 2892, 1020, 0, 0, 0, 0, - 0, 1047, 0, 0, 1906, 556, 0, 0, 1907, 1908, - 0, 1226, 1909, 1910, 1911, 0, 0, -2058, 0, 0, - 1217, 0, 1544, 0, 0, 1540, 0, 0, 0, 3072, - 3274, 0, 0, 0, 0, 0, 0, 1021, 0, 3248, - 0, 0, 0, 0, 0, 1541, 1545, 0, 0, 0, - 557, 3281, 3282, 0, 0, 1671, 1022, 0, 1673, 1540, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1218, - 0, 0, 556, 556, 0, 0, 3295, 3349, 0, 1219, - 853, 0, 0, 0, 0, 0, 2756, 2758, 26, 27, - 28, 1220, 0, 2893, 0, 0, 0, 0, 0, 0, - 1543, 0, 0, 0, 1418, 0, 0, 0, 2944, 0, - 0, 0, 1543, 0, 853, 1751, 0, 0, 0, -1790, - 1904, 1905, 1541, 1221, -2058, 1023, 1925, 853, 0, 0, - 1969, 1641, 1642, 1643, 1644, 1645, 1646, 0, 1540, 0, - 0, 0, 1543, 0, 853, 0, 0, 0, 853, 1543, - 0, 0, 0, 1799, 0, 33, 0, 0, 0, 0, - 1544, 0, 0, 0, 0, 0, 0, 0, 1011, 0, - 0, 0, 0, 1012, 0, 0, 0, 1223, 0, 0, - 0, 1540, 0, 0, 1545, 1543, 0, 0, 0, 1543, - 0, 857, 38, 0, 0, 1543, 0, 0, 0, 0, - 0, 0, 1224, 0, 0, 0, 0, 2142, 0, 1815, - 0, 853, 0, 0, 0, 1913, 0, 853, 1543, -1790, - 0, 1226, 0, 2894, 0, 40, 2895, 0, 0, 1541, - 0, 1853, 1013, 0, 0, 3376, 43, 1420, 0, 0, - 955, 0, 0, 0, 1358, 955, 0, 556, 556, 0, - 556, 955, 44, 0, 0, 0, 0, 1421, 896, 0, - 899, 0, 903, 1541, 0, 0, -1790, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 45, 0, 0, 0, - 0, -1790, 0, 1540, 0, 1914, -1790, 0, 0, 0, - 46, -1790, 0, 0, 0, 0, 0, 0, 0, 0, - -1790, 0, 0, 1544, 1014, -1790, 0, 0, 3464, 1047, - 0, 0, 1906, 0, 0, 1544, 1907, 1908, 0, 0, - 1909, 1910, 1911, 0, 0, 0, 0, 1545, 0, 0, - 1418, 1418, 0, 0, 0, 1762, 1418, -1790, 520, 1545, - 1015, 0, 1541, 0, 0, 1544, 0, 0, 0, 0, - 0, 1004, 1544, 556, 1949, 0, 1016, -1790, 0, 0, - 0, 853, 0, 0, 806, 0, 1017, 806, 0, 1545, - 2944, 0, 806, 0, 3054, 806, 1545, 0, 0, 0, - 806, 0, 556, 0, 556, 1541, 0, 0, 1544, 0, - 0, 0, 1544, 0, 0, 0, 0, 0, 1544, 0, - 1018, 0, 0, 0, 0, 0, -1790, 0, 0, -1790, - 0, 0, 1545, 0, 0, -1790, 1545, 0, 0, 0, - 0, 1544, 1545, 0, 0, 0, 0, 1720, 0, 0, - 0, 0, 0, 0, 0, 0, 1420, 0, 0, 0, - 0, 0, 0, 0, 0, 1545, 1019, 0, 0, 0, - 0, 0, 0, 1020, 0, -1790, 0, 0, 0, 0, - 1421, 1421, 1421, 1421, 1421, 1421, 0, 0, 1421, 1421, - 1421, 1421, 1421, 1421, 1421, 1421, 1421, 1421, 0, 0, - -1790, 0, 0, 0, 0, 0, 0, 1541, 2334, 2053, - 0, 0, 0, 0, 0, 1021, 557, 1915, 1916, 1917, - 2063, 1918, 1919, 1920, 1921, 1922, 1923, 0, 0, 23, - 0, 0, 1358, 1612, 1022, 0, 1613, 1358, 0, 0, - 1614, 1615, 0, 1913, 0, 0, 0, 3184, 0, 0, - 1543, 0, 0, 0, 1612, 0, 0, 1613, 855, 955, - 0, 1614, 1615, 0, 0, 1540, 0, 0, 23, 0, - 0, 1623, 0, 0, 0, 0, 0, 0, -2058, 0, - 0, 0, 0, 0, 1874, 1876, -1790, 0, 0, 0, - 23, 0, 1623, 0, 0, 0, -1790, 0, 0, -2058, - 0, 0, 0, 1023, 0, 1625, 2150, 0, 853, 0, - 853, 0, 0, 1914, 0, -1790, 0, -1790, -1790, 0, - 0, 853, 0, 2166, 2171, 2173, 1625, 0, 0, 0, - 0, 2385, 2386, 2387, 2388, 2389, 2390, 0, 1418, 2394, - 2395, 2396, 2397, 2398, 2399, 2400, 2401, 2402, 2403, 0, - 0, 0, 0, 0, -1790, 0, 0, -1790, -1790, -1790, - 0, 0, 0, 853, 0, 556, 0, 1421, 1421, 0, - 2800, 0, 26, 27, 28, 0, 0, 0, 0, 1751, - 556, 0, 1420, 1420, 0, 1543, 0, 0, 1420, 0, - 556, 2236, 556, 2240, 0, 556, 0, 0, 0, 0, - 0, 556, -2058, 556, 0, 0, 0, 557, 557, 924, - 0, 26, 27, 28, 931, 955, 556, 932, 0, -2058, - 955, 556, 0, -2058, -2058, 556, 556, 556, 556, 0, - 556, 556, 0, 26, 27, 28, 0, 0, 0, 33, - -2058, 0, 1543, 0, 0, -2058, 0, 2298, 0, 0, - 0, 0, 0, 1544, 0, 0, 853, 853, 853, 853, - 1314, 853, -2058, 0, 0, 0, 0, 0, 0, 1541, - 0, 0, 0, 0, 0, 2324, 38, 1545, 33, 0, - 0, 0, 0, -2058, 0, 1421, -1805, 0, 0, 1874, - 1876, 2348, 0, 0, 0, 0, 0, 0, 0, 0, - 33, 1358, 0, 0, 0, 0, 0, 0, 0, 40, - 0, 0, 0, 0, 0, 38, 0, 1634, 2505, 2506, - 43, 0, 0, 557, 0, 1915, 1916, 1917, 0, 1918, - 1919, 1920, 1921, 1922, 1923, 0, 44, 38, 1634, 0, - 0, 1418, 1418, 1418, 1418, 1418, 1418, 1543, 40, 1418, - 1418, 1418, 1418, 1418, 1418, 1418, 1418, 1418, 1418, 43, - 45, 0, 0, 0, 0, 540, 0, 0, 0, 0, - 40, 0, 0, 0, 46, 44, 0, 0, 0, 556, - 0, 43, 0, 0, 0, 0, -1805, 0, 1544, 0, - -1316, 853, 0, 0, 0, 0, 0, 44, 0, 45, - 806, 0, 0, 0, 0, 0, 806, 0, 0, 0, - 0, 556, 1545, 46, 0, 0, 556, 0, 0, -2058, - 0, 45, 0, 0, 0, 2459, 2459, 0, 541, 0, - 0, 0, 0, -1805, 0, 46, 0, 0, 0, 0, - -2058, 0, 1543, 0, 0, 1544, 0, 0, -1805, 0, - 0, 0, 0, -1805, 0, 0, 0, 0, -1805, 0, - 0, 0, 0, 0, 1438, 989, 0, -1805, 0, 1545, - 2189, 0, -1805, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 542, 0, 0, 0, 0, 1469, 0, 0, - 0, 0, 0, 0, 0, 1047, 556, 0, 1906, 0, - 2496, 543, 1907, 1908, -1805, 556, 1909, 1910, 1911, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1543, - 0, 0, 0, 3073, -1805, 0, -2058, 0, 1418, 1418, - 0, 0, 0, 1641, 1642, 1643, 1644, 1645, 1646, 0, - 0, 0, 0, 1165, 0, 2053, 0, -2058, 0, 0, - 1544, 0, 1595, 0, 1641, 1642, 1643, 1644, 1645, 1646, - 544, 0, 0, 1358, 0, 0, 0, -208, 0, 0, - 0, 0, 0, -1805, 1545, 0, -1805, 0, 806, 0, - 0, 0, -1805, 0, 0, 0, 0, 0, 0, 0, - 556, 1292, 0, 1421, 1421, 806, 0, 0, 0, 2166, - 0, 0, 0, 0, 0, 0, 1305, 1307, 1310, 1312, - 545, 0, 546, 0, 0, 0, 0, 0, 0, 557, - 557, 0, -1805, 0, 0, 0, 1543, 0, 0, 547, - 0, 0, 0, 0, 0, 548, 0, 0, 549, 0, - 0, 0, 0, 556, 0, 1544, 1418, -1805, 0, 556, - 0, 0, 0, 0, 0, 0, 0, 0, 1413, 0, - 1543, 0, 0, 0, 0, 1815, 0, 0, 0, 1545, - 0, 0, 0, 1420, 1420, 1420, 1420, 1420, 1420, 0, - 0, 1420, 1420, 1420, 1420, 1420, 1420, 1420, 1420, 1420, - 1420, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 855, 0, 0, 0, 1913, + 524, 57, 1128, 868, 65, 910, 82, 103, 53, 718, + 68, 959, 1231, 1194, 77, 99, 524, 69, 94, 1027, + 854, 1250, 880, 70, 1796, 1301, 1431, 1936, 521, 1807, + 2185, 978, 1159, 1795, 77, 783, 2063, 1688, 1304, 1779, + 1760, 884, 1401, 1483, 815, 1404, 885, 2575, 777, 1405, + 2152, 1357, 1403, 1589, 1812, 1766, 809, 1770, 2610, 2548, + 850, 2550, 1993, 1842, 744, 2024, 2565, 2680, 524, 524, + 2467, 1745, 1868, 1346, 522, 2291, 50, 1230, 1363, 1236, + 51, 1240, 52, 1800, 1664, 55, 1340, 2991, 56, 1667, + 522, 59, 60, 901, 61, 866, 815, 815, 2960, 2087, + 2088, 63, 66, 67, 2603, 2564, 2529, 3005, 809, 809, + 2962, 847, 80, 2989, 2789, 1250, 2650, 2651, 2652, 3008, + 881, 882, 1601, 1009, 893, 961, 2664, -1908, 1030, 972, + 71, 81, 83, 969, 84, 90, 91, 93, -517, 98, + -1333, 2156, 522, 522, 102, 104, -371, 2853, 2317, 2316, + 71, 2858, -863, 808, 2208, 1370, 2321, 2469, -521, -860, + 1566, 1567, -1274, -860, 2205, -855, 2419, 71, 979, 536, + -1271, -1271, 3200, -1908, -1274, -863, 867, 1579, -1255, 3404, + 2672, -2048, -2048, -1899, 819, -1899, -1916, 2102, 1050, -1275, + -1916, -2039, -2039, 1415, -2057, -2057, 2681, -1272, -1272, -1275, + -822, -835, 1050, -850, 819, 808, 808, 883, 2102, 2611, + 858, 2666, 819, 2487, 1672, -2034, -2034, 1751, 2659, 3133, + 819, -1112, -2059, -2059, 2880, 2448, 2449, 3510, 817, -1112, + 2668, 71, -471, 1668, 1350, 819, 2455, 1350, -517, 1050, + 2459, 2753, 1050, 717, 1148, 1913, 2714, 2716, 872, 2719, + 1915, 1050, 3278, 1140, 978, 1620, 1250, 875, -521, 1810, + 1622, 1597, 2754, 950, 1771, 2218, 2982, 2883, 1811, 1913, + 1694, 1183, 3148, 1914, 1915, 3, 4, 1147, 1325, 1186, + 817, 817, 2688, -229, 872, 2429, 537, 1334, -229, 3363, + 1630, 1004, 2139, 1780, 1620, 1334, 1783, 1784, 1621, 1622, + 2140, 1620, 1030, 2431, 2297, 1621, 1622, 1244, 3485, 3291, + 3168, 1913, 1754, 1334, 1009, 1914, 1915, 1326, 877, 1953, + 2612, 3099, 3144, 3101, 1632, -1133, 1571, 1746, 876, 1630, + 877, 3534, 3116, -1133, 1010, 3470, 1630, 3185, 1145, 873, + 3477, 2736, 1581, 2825, 2149, 2827, 3390, 1669, 2896, 1999, + 2606, 1762, 1953, 3408, 819, 3204, 1740, 1741, 1762, 2432, + 1364, 1771, 1798, 1632, 2123, 1691, 836, 1744, 2725, 2638, + 1632, -792, 1173, 2826, 2180, 873, 2089, 3309, -654, 3009, + 3130, 3106, 3224, 1551, 1543, 2313, 2867, 1179, 3371, 1620, + 2834, 3463, 1794, 1705, 3523, 1470, 2211, 3521, 1620, 1584, + 3258, 2239, 3260, 105, 2032, 2876, 877, 3424, 3425, 2540, + 534, 3167, 1149, 2038, 1150, 2866, 3194, 1855, 1814, 3107, + 113, 1585, 2897, 3428, 1630, 3281, 2167, 3206, -517, 1790, + 2887, 2877, 3310, 1458, 3322, 1586, 2849, 3511, 3546, 1465, + 3450, 3311, 3201, 3453, 3323, 2835, 3195, 1471, -521, 1508, + 3372, 2168, 106, 1791, 1304, 3131, 1771, 3202, 1632, 2181, + 3465, 2240, 2603, 1181, 2603, 3312, 3389, 1632, 837, 2298, + 1772, 1670, 1756, 1011, 1174, -530, 3518, 1207, 3493, 2888, + -2033, -2033, 2784, 3145, 2430, 1673, 2607, 3015, 2124, 1801, + -530, 3471, 1204, 2150, 3535, -530, 1327, 2889, 1205, -517, + 1245, 1706, 2433, 1589, 114, 2125, 2898, -792, -674, 3273, + 2126, 1769, 1141, 2212, 2243, 3492, 3364, 3289, 3478, -521, + 3472, 2726, 1049, 3336, 3512, 1913, 3222, 1692, 3283, 1914, + 1915, 3030, 2983, 1916, 1917, 1918, 1769, 3516, 3313, 2753, + 2613, 2219, 2614, 1813, 3308, 3010, -530, 1683, 2127, 2034, + 2798, 3314, 3524, 3513, 859, 1996, 3013, 878, 2103, 3134, + 2754, 925, 3451, 1551, 1543, 3179, -530, 1772, 2442, 2443, + 2444, 3480, 2615, 2998, 2063, 951, 2463, 3021, 3279, 2531, + 874, 1609, 2296, 787, 1335, 718, 1742, 1142, 2234, 1690, + -1112, 1757, 1335, 3001, 1743, 1566, 1567, 959, 2890, 2805, + 1044, 3267, 1870, 1206, 1583, 3299, 1945, 2891, 1874, 2360, + 1335, 3324, 1328, 1960, 908, -530, 2482, -517, 909, 2723, + 1579, 2660, 2661, 1747, -530, 2578, 1562, 978, 1584, 2305, + 1981, 538, 788, 1769, 985, 2960, 2205, -521, 2573, -1908, + 3486, 2552, 1796, 3438, 2314, 1576, 2673, 2962, 3203, 2679, + 1585, 1584, 2567, 1551, 1543, 3539, -517, 2387, -517, 2684, + -1333, 2141, 1772, 1300, 1586, 855, -371, 2846, 71, 2393, + 2366, -860, 2155, 1585, -1274, 3124, -521, -855, -521, 3270, + 2045, 2046, 3244, 2664, 3271, -1908, -1274, 1588, 908, 908, + -1255, 1576, 909, 909, -1133, -1899, 1615, -1899, -1916, 2421, + 1799, -1275, -1916, 2747, 2392, 2128, 2426, 2639, 1151, 2768, + 868, -1275, 1569, 1574, 3388, -850, 1665, 1871, 818, 1568, + 1250, 2083, 1250, 3182, 2157, 972, 998, 3395, 1769, 1878, + 2031, 1597, 3540, 3396, 2847, 2420, 1920, 3198, 1354, 1355, + 1597, 1354, 1355, 3452, 2460, 1336, 977, 1930, 2460, 2632, + 3157, 3158, 3315, 1339, 2066, 3316, 1951, 1653, 1790, 1785, + 1207, 868, 2633, 870, 1571, 2296, 77, 783, 1927, 1928, + 1929, 1930, 861, 3115, 1179, -530, 3142, 2481, 2400, 3439, + 819, 974, 1791, 2084, 1581, 1179, 524, -229, -229, 3199, + 1180, 1648, 1649, 1650, 1651, 1652, 1653, 524, 2239, 3025, + 1650, 1651, 1652, 1653, 1348, 3174, 1921, 1349, 1925, 1926, + 1927, 1928, 1929, 1930, 815, 884, 2381, 1762, 2022, 947, + 885, 2382, 3461, 1209, 3541, 815, 1584, 2427, 1763, 1387, + 1388, 524, 524, 1195, 3117, 2989, 3150, 1000, 1146, 2614, + 1771, 1448, 1762, 908, 3155, 871, 1164, 909, 1585, 1001, + 1181, 3143, 3183, 1765, 524, 1210, 1146, 2269, 2600, 1474, + 522, 1181, 1588, 1478, 2353, 3440, 2427, 2272, 887, 2909, + 2275, 522, 57, 1551, 1543, 65, 3080, 82, 103, 53, + 2383, 68, 71, 867, 2541, 77, 99, 1152, 69, 94, + 2268, 1880, 1681, 3195, 70, 1682, 1050, 2960, 2105, 1182, + 886, 524, 718, 1584, 1786, 1293, 524, 2111, 1609, 2962, + 1182, 1708, 1160, 2976, 1787, 2977, 2436, 847, 847, 3064, + 847, 2401, 3066, 987, 3068, 1585, 1211, 889, 2231, 3304, + 1455, 2402, 540, 3536, 999, 2112, 3357, 3290, 3358, 2292, + 2293, 2294, 2326, 3276, 1869, 108, 2503, 50, 1393, 1394, + 2063, 51, 904, 52, 540, 2267, 55, 1709, 1293, 56, + 2370, 936, 59, 60, 819, 61, 1551, 1543, 1804, 977, + 906, 1455, 63, 66, 67, 2278, 524, 524, 1303, 3542, + 2285, 883, 524, 80, 1346, 524, 524, 2374, 524, 524, + 524, 524, 2359, 77, 783, 541, 2361, 2796, 817, 2363, + 3263, 71, 81, 83, 524, 84, 90, 91, 93, 817, + 98, 524, 1936, -1908, 3410, 102, 104, 541, 1922, 1923, + 1924, 912, 1925, 1926, 1927, 1928, 1929, 1930, 524, 1293, + 1554, 2380, 815, 937, 2553, 2384, 2554, 924, 2386, 815, + 2737, 2738, 2739, 2740, 809, 931, 1772, 540, 868, 524, + 2113, 809, 1771, -598, 2270, 2302, 1451, 943, -598, 2273, + 2115, 1796, 1035, 1462, 2653, 2024, 1016, 908, 524, 2111, + 3384, 1608, 2521, 1036, 2870, -209, 1711, 1869, 522, 524, + 524, 524, 3090, 524, 524, 522, 2573, 3367, 718, 2584, + 543, 935, 2243, 1882, 938, 2648, 3216, 2112, 1050, 23, + 2522, 875, 1017, 3252, 1551, 1543, 2649, 1016, 1771, 71, + 541, 948, 1769, 1829, 3253, 109, -599, 524, 1456, 2425, + 908, -599, -1255, 949, 909, 2640, 110, 1302, 1019, -598, + 953, 2576, 938, 939, 524, 524, 1050, 952, 1712, 1696, + 1697, 808, 1703, 1017, 885, 885, 1954, 885, 808, 1302, + 1146, 1955, 1830, 2143, 954, 1875, -208, 2144, 1876, 1464, + 1463, 111, 2871, 978, 1468, 1039, 1040, 1041, 2675, 1019, + 524, 939, 876, 955, 524, 524, 1771, 545, -598, 968, + 2637, 1601, 1561, 965, 524, 524, 524, 3189, 927, 524, + 928, 2689, -599, 1944, 1573, 1946, 1947, 2697, 1560, 545, + 46, 546, 1379, 1380, 2485, 549, 940, 929, 983, 930, + 1554, 112, 2113, 2116, 984, 1797, 817, 2114, 941, 985, + 2523, 1599, 2115, 817, 2117, 2524, 2763, 549, 2872, 936, + 2873, 986, 1135, 1136, 558, 1138, 2641, 1832, 1577, 1578, + 749, -599, 26, 27, 28, 1293, 1995, 1551, 1543, 1996, + 877, 824, 994, 2343, 1293, 2344, 941, 1023, 1772, 1551, + 1543, 2020, 1217, 989, 2021, 865, 865, 2437, 2310, 2438, + 992, 2311, 1387, 1388, 2375, 993, 1457, 2376, 1293, 2519, + 2413, 995, 1218, 2414, 2549, 2461, -2030, -2030, 2462, 1551, + 1543, 2439, 545, 2440, 968, 996, 1551, 1543, 1023, 997, + 1554, 937, 2063, 998, 2645, 883, 883, 1836, 883, 33, + 1837, 1003, 1839, 1840, 1772, 3026, 718, 1457, 2464, 1032, + 549, 2462, 1607, 3532, 1769, 718, 2628, 2748, 1219, 2629, + 897, 2755, 1042, 2634, 1551, 1543, 2635, 1037, 1551, 1543, + 1049, 1043, 977, 1913, 1551, 1543, 38, 1914, 1915, 1044, + 1708, 1916, 1917, 1918, 2700, 1045, 3519, 1996, 3520, 718, + -2031, -2031, 77, 783, 524, 1204, 3495, 1551, 1543, 1144, + 2760, 1205, 2622, 2462, 2624, 2116, 1139, 974, 2525, 40, + 1769, 3507, 1772, 2587, -2032, -2032, 2117, 1204, 2958, 2526, + 43, 1393, 1394, 1205, 1702, 2761, 1709, 1155, 2021, 3545, + 1829, 878, 2764, 2766, 1161, 2765, 2765, 116, 2907, 1168, + 2841, 535, 1162, 2842, 524, 524, 1164, 1204, 2900, 748, + 524, 2671, 524, 1205, 1220, -2035, -2035, 524, 524, 524, + 524, 2999, 2975, 835, 2376, 2864, 3543, 848, 2625, 1830, + 2627, 3544, 524, 524, 46, -2036, -2036, 524, 1769, 524, + 815, 3000, 524, 3019, 2311, 1169, 3020, 524, 1177, 524, + 524, 2899, 524, 2908, 1710, 3027, 524, 2985, 3028, -2037, + -2037, 2785, 2786, 1221, 1831, 815, 1206, 815, 71, 3081, + 815, 3217, 2021, 1222, 2021, 815, 1165, 809, 815, 809, + 815, 2863, 809, 2865, 815, 1223, 522, 809, 1206, 1972, + 809, 1973, 809, 1166, 1975, 3218, 809, 23, 2462, 1979, + 3247, 1196, 1982, 2021, 1983, 1711, 1199, 3353, 1987, 3354, + 1554, 522, 3254, 522, 1832, 1996, 522, 1224, 1206, 3264, + 1201, 522, 3265, 2771, 522, 1601, 522, 2773, 2775, 1597, + 522, 2774, 2776, 2777, 2772, 3297, 3298, 1202, 2376, 2311, + 1863, 1215, 524, 524, 1920, 3333, 3393, 3406, 2021, 2376, + 3407, 524, 524, 1203, 2023, 3432, 2025, 1216, 3433, 524, + 77, 2030, 3476, 2026, 2029, 3407, 524, 1712, 1233, 2027, + 3517, 1226, 1237, 3407, 808, 1176, 808, 1178, 1241, 808, + -2038, -2038, 1242, 1885, 808, -2040, -2040, 808, 1296, 808, + 1299, 718, 1300, 808, 1305, 524, 1227, 1307, 524, -2041, + -2041, -2042, -2042, 1554, 524, 524, 524, 524, 524, 524, + 524, 524, 718, 2573, 1921, 1229, 524, 524, 2706, -2043, + -2043, 524, 1311, 1207, 817, 524, -2044, -2044, 524, 524, + 524, 524, 524, 524, 524, 524, 524, 978, 2152, 524, + 26, 27, 28, -2045, -2045, 1207, 524, 1321, 1293, 817, + 1323, 817, -2046, -2046, 817, -2047, -2047, 3161, 2187, 817, + -2049, -2049, 817, 885, 817, 1324, 2083, 524, 817, -2050, + -2050, 1331, 1551, 1543, 1332, 1207, 71, -2051, -2051, -2052, + -2052, 1338, 1208, -2053, -2053, 1341, 1209, 1342, 3125, 1347, + 524, 1365, 2907, -2054, -2054, -2056, -2056, -2058, -2058, 1442, + 1152, 524, 524, 1366, 1234, -2060, -2060, 33, 1209, 1816, + 1817, 2206, 2207, 1371, 1204, -649, -649, 1424, 1210, 1429, + 1205, -653, -653, -652, -652, 1389, 1390, 1393, 1394, 1445, + 3482, 3121, 3122, 1452, 1238, 3503, 3504, 1444, 1209, 1459, + 1235, 1554, 2857, 1460, 38, 3529, 3530, 1676, 1677, 1466, + 718, 1467, 718, 2592, 2593, 2109, 1049, 1999, 1477, 1913, + 1473, 3178, 1479, 1914, 1915, 1556, 945, 1916, 1917, 1918, + 1239, 2993, 2981, 540, 1557, 1559, -826, 40, 3494, -833, + 1572, 1568, 3496, 46, 1204, 3011, -823, -674, 43, 1211, + 1205, -675, 524, -824, 1582, -827, 1293, 2047, -1319, 524, + 524, 3332, 1583, -825, 2048, 2049, 1551, 1543, 2050, 2051, + 2052, 1211, 1606, 3243, 3092, 1593, 1425, 1612, 1614, 1659, + 1661, 3018, 1675, 1663, 883, 1206, 1922, 1923, 1924, 1685, + 1925, 1926, 1927, 1928, 1929, 1930, 541, 3537, 1684, 1689, + 1293, 1211, 46, 1693, 1180, 1695, 2099, 1182, 1730, 1732, + 1734, 1749, 718, 1767, 1768, 1769, 1774, 1793, 1776, 1293, + 524, 1775, 1789, 1551, 1543, 1781, 2347, 1788, 977, 1803, + 113, 1809, 1819, 1820, 1825, 2573, 1888, 1828, 1821, 1834, + 1835, 1851, 1843, 1847, 1554, 1844, 1850, 1853, 524, 524, + 2325, 524, 1854, 1856, 1857, 1206, 1554, 524, 524, 524, + 524, 524, 524, 1864, 913, 524, 524, 524, 524, 524, + 524, 524, 524, 524, 524, 2958, 1865, 1869, 1877, 1905, + 524, 524, 1902, 1889, 524, 1904, 1554, 1907, 1910, 1933, + 914, 524, 1942, 1554, 1941, 1949, 1952, 1970, 1974, 1980, + 1984, 1985, 1986, 1997, 1890, 1991, 1562, 1919, 2003, 1569, + 1994, 1574, 3332, 524, 1998, 2002, 2000, 524, 964, 524, + 2034, 2328, 1891, 524, 1050, 3153, 1892, 2001, 1551, 1543, + 1920, 1554, 2067, 71, 3295, 1554, 2033, 524, 2068, 1293, + 1620, 1554, 1207, 2073, 2255, 815, 2259, 2076, 2078, 1893, + 2079, 815, 1894, 2080, 2081, 3332, 915, 809, 2101, 2108, + 2119, 2120, 2122, 809, 1554, 1723, 2146, 2147, 1895, 2450, + 2153, 2165, 2166, 3063, 1425, 2453, 524, 524, 545, 2170, + 968, 2183, 876, 2186, 2195, 916, 2197, 3162, 3163, 2196, + 2198, 522, 2199, 2200, 1373, 1374, 2217, 522, 2221, 2222, + 1921, 2230, 2225, 548, 3332, 1209, 549, 2232, 1204, 877, + 2236, 2237, 1207, 2238, 1205, 868, 524, 2308, 2312, 2318, + 1601, 524, 524, 1551, 1543, 2327, 2329, 2330, 917, 2331, + 2332, 3386, 2333, 865, 2334, 1375, 1376, 1210, 2348, 1377, + 1378, 2572, 2349, 2351, 2354, 2355, 524, 524, 2358, 2377, + 2356, 524, 2385, 1938, 808, 2362, 2415, 1913, 2422, 1937, + 808, 1896, 3348, 2423, 2434, 524, 2446, 2424, 524, 1897, + 524, 2276, 2428, 2435, 2452, 1209, 2454, 2466, 2468, 2473, + 2474, 2477, 2478, 2494, 2475, 2479, 524, 718, 2480, 2499, + 2483, 1898, 2484, 524, 2495, 2500, 524, 3139, 2491, 2492, + 1551, 1543, 2520, 2496, 2497, 1911, 1912, 2277, 1211, 2498, + 2527, 1932, 2501, 524, 2502, 1379, 1380, 2515, 2512, 1206, + 1899, 2513, 2536, 2537, 815, 2542, 524, 2544, 2543, 817, + 2556, 2558, 2560, 2555, 2561, 817, 809, 2958, 2568, -655, + 2569, 815, 2566, 524, 524, 2579, 2580, 2583, 2586, 2582, + 2590, 2594, 1747, 809, 2591, 918, 2598, 2599, 2602, 2596, + 524, 1049, 524, 2621, 1913, 2623, 919, 2656, 1914, 1915, + 522, 2654, 1916, 1917, 1918, 524, 2636, 1796, 1211, 1381, + 1382, 1383, 1384, 1385, 1386, 1387, 1388, 522, 1599, 1389, + 1390, 2670, 2642, 718, 718, 718, 3284, 2674, 2643, 2655, + 2644, 920, 2687, 2657, 1425, 1425, 2109, 1551, 1543, 2690, + 1425, 2669, 1922, 1923, 1924, 2686, 1925, 1926, 1927, 1928, + 1929, 1930, 2538, 2691, 921, 2694, 2698, 2713, 2721, 2703, + 2724, 2727, 524, 808, 868, 2745, 2730, 2744, 1293, 2731, + 2756, 1551, 1543, 2732, 2733, 2757, 2770, 2762, 978, 2781, + 808, 922, 2793, 2053, 2054, 2055, 2778, 2056, 2057, 2058, + 2059, 2060, 2061, 1391, 1392, 520, 531, 1836, 2803, 2804, + 1837, 556, 1839, 1840, 718, 2787, 1207, 556, 2822, 1554, + 2816, 806, 2850, 820, 2831, 2854, 2862, 823, 556, 831, + 2801, 2807, 831, 2817, 2895, 849, 853, 524, 2824, 853, + 2911, 2848, 556, 556, 1393, 1394, 2828, 2852, 817, 2869, + 2875, 524, 977, 2868, 2978, 2979, 2992, 2980, 2987, 718, + 1551, 1543, 2984, 2988, 2083, 817, 2996, 2346, 3002, 3003, + 2997, 3007, 865, 806, 806, 2283, 3016, 2311, 3023, 1209, + 3024, 3049, 3029, 3051, 3337, 3055, 3339, 3059, 23, 3347, + 3069, 3070, 2220, 3072, 3073, 3093, 3100, 524, 3103, 849, + 3105, 3112, 3114, 1551, 1543, 3118, 853, 556, 853, 853, + 853, 2284, 3128, 3119, 3132, 1920, 3136, 3120, 3126, 3127, + 3137, 3138, 3146, 3149, 3151, 815, -2029, 3152, 3156, -2030, + -2031, -2032, -2033, 3170, 3349, -2034, 3351, 524, 3171, 1395, + 1396, 3169, 3186, 3469, 3190, 3205, -2035, 867, 3209, -2036, + 3172, 868, 3173, 1554, 1146, 3430, 3210, -2037, -2038, -2040, + -2041, 819, 3175, 1397, 1398, -2042, -2043, 2255, 2255, 2255, + 524, 522, -2044, -2045, 3176, 3423, 524, 524, 3434, -2046, + 3184, 2819, 1211, 2005, 868, 1921, -2047, 524, 3207, 3219, + -2049, -2050, 3220, -2051, -2052, -2053, -2054, -2055, 524, -2056, + -2057, 524, -2058, 524, 3418, 1551, 1543, -2059, -2060, -1272, + 1554, 524, 3227, 3191, 524, 524, 3193, 3213, 3223, 524, + 524, 3225, 3237, 3231, 3233, 3239, 524, 3261, 3234, 3238, + 2194, 26, 27, 28, 3242, 2856, 3246, 3262, 3266, 3269, + 3274, 524, 3286, 3272, 3287, -1271, 3294, 3296, 1885, 3303, + 1872, 524, 1873, 3305, 2023, 3306, 2025, 3319, 3320, 3334, + 77, 2030, 3321, 2026, 2029, 3335, 3341, 3338, 3342, 2027, + 3355, 524, 3350, 3145, 3375, 2840, 3344, 3379, 1049, 3381, + 3382, 1913, 14, 15, 3385, 1914, 1915, 3391, 3398, 1916, + 1917, 1918, 3400, 1885, 3399, 3404, 3409, 3096, 33, 3411, + 3413, 3416, 3417, 3420, 3421, 3422, 2799, 3429, 3431, 817, + 3427, 3441, 718, 3436, 3447, 2961, 718, 3448, 718, 3464, + 3449, 3456, 3474, 3454, 1599, 3455, 3466, 3468, 23, 3484, + 524, 3487, 524, 3489, 3508, 38, 3505, 3486, 2394, 2395, + 2396, 2397, 2398, 2399, 3522, 3485, 2403, 2404, 2405, 2406, + 2407, 2408, 2409, 2410, 2411, 2412, 3527, 1599, 3533, 3538, + 3458, 3548, 3547, 2910, 1836, 1167, 2263, 1837, 40, 1839, + 1840, 2914, 2619, 3362, 2843, 3426, 71, 1049, 3462, 43, + 1913, 3531, 71, 2990, 1914, 1915, 3159, 2364, 1916, 1917, + 1918, 2705, 3445, 1143, 3515, 44, 868, 1922, 1923, 1924, + 3282, 1925, 1926, 1927, 1928, 1929, 1930, 524, 2855, 3483, + 1554, 3012, 3509, 1545, 3014, 821, 3490, 3318, 2601, 45, + 1759, 3006, 2626, 3481, 3488, 2879, 2597, 524, 524, 2964, + 3479, 1867, 524, 46, 1833, 524, 2665, 1425, 1425, 1425, + 1425, 1425, 1425, 2710, 3214, 1425, 1425, 1425, 1425, 1425, + 1425, 1425, 1425, 1425, 1425, 2585, 1449, 2571, 2224, 1686, + -530, 2986, 524, 1727, 3467, 1450, 1726, 1551, 1543, 2192, + 2581, 26, 27, 28, 3412, -530, 524, 1546, 2735, 3340, + -530, 524, 524, 2223, 810, 868, 524, 1554, 1731, 2458, + 71, 524, 1920, 2557, 524, 524, 3058, 3241, 1002, 524, + 1293, 988, 1416, 524, 910, 905, 2729, 524, 2728, 557, + 2759, 3288, 3415, 2472, 524, 557, 1400, 2372, 71, 2373, + 1013, 71, 3414, 2574, 23, 1014, 557, 2516, 2517, 2510, + 2783, -530, 2534, 2532, 2488, 815, 1402, 853, 33, 1406, + 557, 557, 853, 1961, 1407, 853, 2255, 809, 1408, 35, + 2963, -530, 2259, 556, 1409, 2511, 1410, 1411, 524, 1451, + 3104, 2795, 1921, 2829, 3402, 1412, 524, 2306, 1198, 1599, + 1879, 37, 2465, 2161, 2646, 38, 2844, 2163, 982, 1805, + 894, 522, 0, 0, 1015, 524, 0, 0, 0, 0, + 0, -2061, 0, 1545, 1554, 2880, 0, 0, 0, 1049, + -530, 2881, 1913, 0, 0, 557, 1914, 1915, 40, -530, + -2061, -2061, -2061, 0, 2882, 0, 0, 0, 0, 43, + 0, 0, 0, 0, 0, 0, 1425, 1425, 2961, 0, + 0, 0, 1217, 0, 0, 44, 0, 0, 2883, 0, + 2884, 0, 0, 0, 808, 0, 2836, 0, 0, 0, + 0, 0, 1218, 0, 0, 0, 1016, 1546, 867, 45, + 0, 1921, 0, 0, 2235, 0, 0, 26, 27, 28, + 718, 0, 0, 46, 2244, 524, 2247, 0, 0, 2258, + 0, 0, 0, 1545, 0, 2262, 868, 2264, 0, 0, + 0, 0, 1017, 0, 0, 0, 0, 0, 1219, 0, + 2271, 23, 0, 977, 0, 2274, 524, 1554, 1018, 2279, + 2280, 2281, 2282, 0, 2286, 2287, 3197, 0, 1019, 817, + 0, 0, 524, 0, 0, 0, 0, 0, 2885, 0, + 0, 0, 0, 0, 33, 0, 0, 0, 0, 0, + 1425, 0, 0, 957, 556, 556, 0, 1546, 0, 0, + 1554, 0, 1020, 0, 0, 524, 0, 0, 0, 0, + -530, 0, 0, 0, 0, 0, 524, 524, 2903, 0, + 524, 38, 524, 1193, 1922, 1923, 1924, 0, 1925, 1926, + 1927, 1928, 1929, 1930, 0, 980, 531, 0, 0, 0, + 0, 520, 0, 853, 1220, 0, 2886, 524, 1021, 0, + 0, 2887, 806, 0, 40, 1022, 1006, 1006, 0, 0, + 0, 1006, 1029, 0, 0, 43, 0, 0, 0, 0, + 0, 524, 0, 71, 831, 831, 831, 0, 908, 0, + 0, 44, 909, 2837, 0, 0, 0, 0, 831, 831, + 0, 831, 0, 1221, 26, 27, 28, 1023, 0, 0, + 2888, 0, 2961, 1222, 853, 45, 0, 0, 0, 1599, + 556, 0, 0, 0, 0, 1223, 1024, 0, 2889, 46, + 0, 0, 853, 1922, 1923, 1924, 718, 1925, 1926, 1927, + 1928, 1929, 1930, 1921, 0, 0, 853, 820, 0, 0, + 0, 0, 524, 0, 0, 0, 524, 1224, 0, 3300, + 3301, 0, 0, 1545, 1885, 0, 524, 0, 524, 0, + 524, 33, 0, 0, 524, 0, 524, 0, 524, 0, + 0, 853, 1298, 0, 815, 0, 0, 0, 0, 524, + 0, 0, 0, 1309, 524, 1025, 524, 853, 853, 853, + 853, 0, 0, 0, 524, 0, 0, 0, 38, 0, + 0, 1226, 0, 1330, 0, 2809, 2810, 718, 0, 0, + 0, 0, 524, 0, 1426, 0, 0, 1546, 0, 2890, + 522, 0, 0, 0, 0, 3359, 1227, 3361, 2891, 0, + 0, 40, 0, 0, 1013, 1006, 1029, 0, 853, 1014, + 0, 1423, 43, 0, 0, 1229, 1545, 1006, 1006, 0, + 0, 0, 0, 556, 0, 0, 71, 71, 44, 806, + 0, 524, 1049, 0, 0, 1913, 806, 0, 3394, 1914, + 1915, 524, 0, 1916, 1917, 1918, 556, 0, 0, 0, + 0, 0, 45, 524, 3397, 0, 0, 0, 3401, 0, + 3083, 0, 1558, 0, 0, 0, 2838, 524, 1015, 0, + 0, 557, 0, 0, 1425, 1425, 0, 0, 0, 0, + 1546, 1049, 0, 0, 1913, 524, 0, 0, 1914, 1915, + 0, 0, 1916, 1917, 1918, 815, 1872, 0, 0, 0, + 0, 0, 71, 0, 71, 0, 0, 0, 0, 3084, + 524, 556, 14, 15, 0, -2061, -2061, -2061, 0, 1925, + 1926, 1927, 1928, 1929, 1930, 524, 0, 0, 817, 0, + 1885, 0, 0, 0, 2961, 0, 718, 0, 815, 0, + 1016, 522, 0, 0, 0, 71, 0, 0, 1190, 0, + 0, 0, 540, 0, 1545, 0, 0, 0, 23, 524, + 0, 71, 1678, 0, 1680, 71, 0, 0, 3022, 0, + 0, 0, 0, 524, 524, 524, 1017, -1319, 0, 556, + 556, 3491, 1426, 0, 522, 0, 853, 815, 0, 0, + 0, 0, 1018, 0, 0, 0, 0, 981, 0, 0, + 524, 0, 1019, 0, 0, 0, 0, 3506, 0, 1423, + 0, 3368, 0, 0, 0, 541, 0, 0, 1546, 0, + 0, 853, 1758, 0, 0, 0, 0, 0, 1034, 0, + 0, 0, 0, 522, 853, 0, 1020, 0, 0, 0, + 0, 524, 0, 0, 0, 0, 1920, 0, 0, 0, + 0, 853, 1137, 0, 0, 853, 0, 1191, 0, 0, + 1806, 0, 557, 557, 0, 0, 0, 1425, 0, 967, + 0, 0, 0, 0, 0, 0, 1548, 2693, 0, 817, + 0, 0, 1021, 0, 0, 0, 0, 0, 71, 1022, + 0, 0, 3052, 0, 0, 1920, 0, 1545, 0, 821, + 0, 26, 27, 28, 0, 0, 0, 0, 0, 1545, + 0, 0, 0, 0, 71, 0, 1921, 0, 1822, 0, + 853, 0, 817, 0, 0, 0, 0, 3141, 0, 853, + 0, 1023, 1217, 0, 0, 0, 3076, 0, 0, 1545, + 1860, 0, 0, 0, 0, 0, 1545, 544, 0, 957, + 1024, 0, 1218, 0, 957, 0, 556, 556, 0, 556, + 957, 1546, 0, 0, 0, 1921, 0, 0, 33, 0, + 3368, 817, 0, 1546, 0, 0, 0, 0, 557, 35, + 0, 0, 0, 0, 1545, 0, 1356, 0, 1545, 0, + 0, 0, 0, 0, 1545, 0, 1399, 545, 1219, 968, + 0, 37, 0, 1546, 0, 38, 0, 0, 0, 0, + 1546, 0, 1426, 1426, 0, 1013, 547, 1545, 1426, 1025, + 1014, 0, 548, 0, 1192, 549, 1425, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 40, 1423, + 1423, 0, 0, 0, 0, 1423, 0, 520, 1546, 43, + 0, 0, 1546, 0, 0, 0, 1548, 0, 1546, 0, + 1006, 1359, 556, 1956, 0, 44, 0, 3215, 0, 0, + 853, 0, 806, 0, 806, 0, 0, 806, 0, 1015, + 0, 1546, 806, 0, 0, 806, 0, 806, 0, 45, + 0, 806, 0, 556, 1220, 556, 0, 0, 0, 0, + 0, 0, 0, 46, 0, 0, 0, 0, 0, 0, + 1613, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1616, 1443, 2859, 0, 0, 2860, 0, 0, 1922, 1923, + 1924, 0, 1925, 1926, 1927, 1928, 1929, 1930, 0, 857, + 1666, 0, 0, 1221, 1476, 0, 1548, 0, 0, 1671, + 0, 1016, 2912, 1222, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1223, 1425, 2965, 2966, 2967, + 2968, 2969, 2970, 2971, 2972, 2973, 2974, 1922, 1923, 1924, + 0, 1925, 1926, 1927, 1928, 1929, 1930, 1017, 0, 0, + 0, -1791, 0, 0, 0, 1617, 0, 1224, 0, 0, + 2062, 0, 0, 1018, 0, 0, 896, 1549, 899, 1602, + 903, 2072, 0, 1019, 0, 0, 0, 0, 0, 0, + 0, 0, 1550, 0, 1359, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1544, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, -1805, 0, 0, 1815, 0, 0, 1543, - 0, 0, 853, -1805, 2798, 2799, 1545, 0, 0, 0, - 0, 0, 0, 0, 1815, 853, 853, 853, 0, 0, - 0, 0, -1805, 0, -1805, -1805, 0, 0, 556, 0, - 853, 0, 0, 853, 0, 0, 0, 1314, 0, 1914, - 0, 853, 1543, 0, 0, 0, 1421, 955, 0, 0, - 0, 0, 0, 0, 557, 557, 0, 557, 0, 0, - 0, -1805, 0, 0, -1805, -1805, -1805, 1815, 1815, 0, - 1815, 1421, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1544, - 0, 0, 0, 0, 1047, 0, 0, 1906, 0, 520, - 0, 1907, 1908, 0, 0, 1909, 1910, 1911, 0, 0, - 0, 0, 0, 1545, 0, 0, 0, 0, 0, 2723, - 1420, 1420, 0, 1544, 0, 0, 0, 853, 853, 853, - 1743, 0, 0, 0, 0, 0, 556, 0, 1418, 556, - 0, 0, 0, 1770, 1543, 556, 0, 1545, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1020, 0, 0, + 957, 1226, 2151, 0, 0, 0, 0, 0, 0, 0, + 3196, 0, 0, 0, 0, 0, 0, 0, 1976, 0, + 0, 0, 1619, 0, 0, 1620, 1227, 557, 557, 1621, + 1622, 23, 0, -2061, -2061, -2061, 0, 0, 0, 0, + 0, -1791, 0, 1021, 0, 1229, 0, 2159, 1426, 853, + 1022, 853, 0, 1359, 0, 0, 1359, 1359, 0, 0, + 1630, 853, 0, 2175, 0, 0, 0, 1631, 0, 0, + 0, 0, 0, 0, 0, 1423, 0, 0, 0, 0, + 0, 0, 1545, 0, 0, 0, 0, 0, -1791, 0, + 0, 0, 1023, 0, 1632, 0, 0, 0, 0, 0, + 853, 0, 556, -1791, 0, 0, 0, 0, -1791, 0, + 0, 1024, 0, -1791, 2226, 2228, 1548, 0, 0, 0, + 1758, 556, -1791, 0, 0, 1884, 3346, -1791, 0, 0, + 0, 556, 2245, 556, 2249, 0, 556, 1549, 0, 0, + 0, 0, 556, 0, 556, 0, 1546, 0, 0, 0, + 0, 0, 1550, 0, 0, 0, 957, 556, 0, -1791, + 0, 957, 556, 3140, 0, 0, 556, 556, 556, 556, + 0, 556, 556, 0, 26, 27, 28, 0, 0, -1791, + 1025, 0, 0, 0, 0, 1977, 0, 0, 2307, 1881, + 1883, 1633, 0, 0, 0, 0, 1309, 0, 853, 853, + 853, 853, 853, 0, 557, 557, 0, 557, 1634, 1548, + 0, 0, 0, 1635, 0, 0, 1545, 0, 0, 2336, + 0, 23, 0, 0, 0, 0, 0, 1549, -1791, 0, + 0, -1791, 2357, 0, 0, 0, 0, -1791, 0, 0, + 0, 33, 1550, 0, 0, 0, 0, 0, 0, 0, + 0, 1638, 0, 0, 0, 1426, 1426, 1426, 1426, 1426, + 1426, 0, 0, 1426, 1426, 1426, 1426, 1426, 1426, 1426, + 1426, 1426, 1426, 1545, 0, 0, 0, -1791, 38, 0, + 1546, 0, 1423, 1423, 1423, 1423, 1423, 1423, 0, 0, + 1423, 1423, 1423, 1423, 1423, 1423, 1423, 1423, 1423, 1423, + 0, 0, -1791, 0, 0, 0, 1641, 0, 0, 0, + 557, 40, 0, 0, 0, 0, 0, 0, 0, 0, + 556, 0, 43, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 853, 0, 0, 0, 0, 1546, 44, 0, + 0, 1988, 806, 1992, 0, 0, 0, 1548, 806, 0, + 0, 0, 0, 3360, 556, 0, 0, 0, 0, 556, + 855, 0, 45, 0, 26, 27, 28, 0, 2470, 2470, + 0, 0, 0, 0, 0, 0, 46, 0, 1545, 0, + 0, 0, 0, 0, 0, 0, 0, 926, -1791, 0, + 0, 0, 933, 0, 0, 934, 0, 0, -1791, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1643, 2039, + 0, 0, 0, 0, 0, 0, 0, -1791, 0, -1791, + -1791, 2069, 0, 2070, 0, 0, 0, 1013, 0, 0, + 3285, 33, 1014, 2158, 0, 0, 0, 0, 0, 556, + 0, 0, 1546, 2507, 1426, 1426, 0, 1549, 556, 2085, + 0, 3292, 3293, 0, 0, 0, -1791, 0, 0, -1791, + -1791, -1791, 1550, 0, 0, 0, 0, 0, 38, 0, + 0, 1423, 1423, 1545, 0, 0, 0, 3307, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 2062, 0, + 1548, 1015, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 40, 1548, 0, 0, 0, 2227, 2229, 0, 0, + 0, 540, 43, 0, 0, 1644, 0, 0, -2061, -2061, + -2061, 806, 1648, 1649, 1650, 1651, 1652, 1653, 44, 0, + 0, 0, 1548, 556, 0, 0, -1319, 1546, 806, 1548, + 1549, 0, 2175, 0, 0, 0, 0, 0, 0, 0, + 1545, 0, 45, 2204, 2204, 1550, 0, 0, 1426, 0, + 0, 0, 0, 1016, 0, 2288, 46, 0, 0, 0, + 0, 0, 0, 0, 541, 0, 0, 1548, 2303, 2303, + 0, 1548, 556, 0, 0, 1423, 0, 1548, 556, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1017, + 557, 0, 0, 0, 0, 0, 0, 0, 1822, 0, + 1548, 0, 0, 0, 1546, 1018, 0, 1359, 0, 557, + 0, 0, 0, 0, 0, 1019, 0, 1359, 542, 557, + 1359, 557, 1217, 0, 557, 0, 0, 0, 0, 0, + 557, 0, 557, 991, 0, 1356, 0, 543, 0, 0, + 0, 2379, 1218, 0, 0, 557, 0, 1545, 0, 1020, + 557, 0, 0, 0, 557, 557, 557, 557, 0, 557, + 557, 0, 0, 0, 0, 0, 0, 0, 1549, 1822, + 0, 0, 0, 0, 0, 0, 853, 0, 0, 0, + 0, 1545, 0, 1550, 0, 0, 0, 1309, 1219, 2901, + 1822, 853, 853, 853, 0, 1021, 544, 0, 3475, 2902, + 0, 0, 1022, -208, 556, 0, 853, 0, 0, 853, + 1359, 1546, 0, 0, 853, 0, 0, 0, 0, 0, + 957, 0, 0, 0, 0, 0, 1197, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 557, 0, 0, 0, 1795, 853, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1612, 0, 0, 1613, 2053, - 0, 0, 1614, 1615, 1616, 1617, 1618, 1619, 1620, 1979, - 0, 1983, 0, 0, 0, 0, 0, 3011, 0, 0, - 0, 0, 1544, 1621, 0, 1421, 0, 0, 0, 0, - 0, 0, 0, 1623, 1418, 1418, 0, 0, 0, 0, - 1624, 0, 0, 0, 0, 0, 1545, 1820, 0, 0, - 0, 0, 0, 1836, 0, 0, 0, 0, 1420, 0, - 0, 0, 0, 2822, 0, 1544, 0, 1625, 0, 2166, - 0, 1915, 1916, 1917, 0, 1918, 1919, 1920, 1921, 1922, - 1923, 0, 0, 0, 0, 0, 0, 853, 0, 1545, - 0, 556, 0, 0, 0, 556, 556, 556, 0, 0, - 0, 1815, 1751, 1815, 0, 1853, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 556, 0, 2902, 0, -2058, 0, + 1822, 1822, 0, 1822, 1023, 1546, 545, 0, 546, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 2903, 0, + 1545, 1297, 0, 1024, 0, 547, 0, 0, 0, 0, + 0, 548, 520, 0, 549, 0, 0, 1313, 1315, 1318, + 1320, 0, 0, 0, 1220, 1204, 0, 0, 0, 0, + 0, 1205, 2734, 0, 0, 0, 0, 0, 0, 1217, + 853, 853, 853, 1545, 0, 0, 0, 0, 557, 0, + 556, 1549, 1423, 0, 556, 0, 0, 0, 0, 1218, + 556, 0, 0, 1549, 1546, 0, 1550, 0, 1418, 0, + 2476, 0, 1025, 1221, 0, 0, 0, 0, 1550, 0, + 853, 0, 2457, 1222, 0, 0, 0, 1992, 0, 0, + 0, 0, 0, 1549, 2062, 1223, 0, 2904, 0, 0, + 1549, 0, 1426, 1426, 0, 1219, 0, 1546, 1550, 0, + 0, 0, 0, 0, 0, 1550, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1224, 0, 1423, + 1423, 0, 0, 0, 0, 0, 1206, 0, 1549, 0, + 0, 0, 1549, 0, 0, 1545, 0, 0, 1549, 0, + 0, 0, 0, 1550, 0, 1548, 0, 1550, 2833, 0, + 0, 0, 0, 1550, 2175, 0, 0, 557, 0, 0, + 0, 1549, 0, 0, 0, 0, 1602, 0, 0, 0, + 853, 1226, 0, 0, 556, 0, 1550, 0, 556, 556, + 0, 0, 556, 0, 0, 0, 1822, 1758, 1822, 0, + 1860, 1220, 0, 0, 0, 0, 1227, 0, 0, 1546, 0, 0, 0, 0, 0, 0, 0, 0, 0, 556, - 556, 556, 556, 556, 556, 556, 556, 556, 556, 0, + 0, 2913, 2551, 0, 0, 1229, 0, 2905, 0, 0, + 2906, -1793, 0, 0, 556, 556, 556, 556, 556, 556, + 556, 556, 556, 556, 0, 0, 0, 2630, 0, 0, + 1221, 0, 0, 0, 0, 2577, 2577, 0, 0, 0, + 1222, 557, 0, 0, 0, 0, 0, 2336, 0, 0, + 0, 0, 1223, 853, 0, 0, 0, 0, 0, 0, + 0, 1750, 0, 0, 0, 1758, 0, 0, 0, 1548, + 0, 0, 0, 1207, 1777, 1426, 0, 0, 0, 2662, + 0, 1860, 0, 0, 1224, 0, 0, 0, 0, 0, + 557, 1822, 0, 0, 0, 1802, 2589, 2676, 0, 0, + 1426, 0, 1423, 0, 0, 0, 0, 0, 556, 0, + 0, -1793, 0, 0, 0, 853, 853, 853, 853, 1769, + 0, 0, 0, 0, 0, 0, 1548, 1423, 0, 0, + 1423, 0, 1225, 0, 556, 957, 1209, 0, 1226, 1356, + 0, 0, 0, 3067, 0, 0, 0, 0, 2711, 0, + 2712, 0, 0, 0, 2717, 0, 2720, 0, -1793, 0, + 1827, 0, 0, 1227, 0, 0, 0, 0, 1228, 1846, + 3074, 0, 0, -1793, 0, 0, 0, 0, -1793, 0, + 0, 0, 1229, -1793, 0, 0, 0, 1545, 0, 0, + 0, 0, -1793, 0, 0, 0, 0, -1793, 0, 0, + 3097, 0, 806, 0, 0, 0, 0, 1619, 0, 0, + 1620, 0, 0, 0, 1621, 1622, 3109, 0, 0, 0, + 2175, 0, 557, 0, 0, 0, 2062, 0, 0, -1793, + 0, 1548, 0, 0, 1426, 0, 0, 0, 0, 1211, + 1758, 0, 0, 0, 0, 1630, 1822, 0, 0, -1793, + 0, 1546, -2061, 0, 0, 0, 0, 0, 0, 957, + 556, 1423, 0, 0, 0, 0, 1549, 853, 0, 0, + 1619, 0, 0, 1620, 0, 0, 0, 1621, 1622, 1632, + 0, 1550, 0, 0, 3160, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, -1793, 0, + 0, -1793, 0, 0, 0, 0, 0, -1793, 1630, 0, + 1968, 0, 0, 0, 0, -2061, 0, 0, 0, 2767, + 2769, 0, 0, 0, 0, 0, 1548, 0, 557, 0, + 0, 0, 557, 0, 0, 0, 0, 0, 1988, 0, + 0, 0, 1632, 0, 2518, 0, 0, -1793, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1626, 1421, 0, 1544, 0, 0, - 0, 2324, 0, 0, 0, 0, 3130, 0, 853, 0, - 0, 1627, 0, 0, 0, 0, 1628, 0, 1751, 0, - 0, 1545, 0, 0, 0, 0, 0, 1961, 1914, 0, - 0, 0, 0, 0, 0, 0, 1853, 0, 0, 1629, - 1630, 0, 0, 0, 0, 0, 1815, 0, 0, 0, - 0, 0, 0, 0, 1631, 0, 1543, 1418, 0, 0, - 0, 0, 0, 556, 0, 0, 0, 0, 0, 0, - 853, 853, 853, 853, 0, 0, 0, 0, 0, 0, - 0, 0, 1418, 0, 0, 1418, 0, 0, 0, 556, - 955, 0, 1632, 0, 0, 1633, 0, 0, 3056, 1201, - 0, 0, 557, 0, 0, 1202, 0, 0, 0, 1634, - 0, 0, 1635, 1214, 0, 0, 0, 557, 0, 0, - 0, 0, 0, 0, 0, 3063, 0, 557, 0, 557, - 0, 0, 557, 1215, 0, 0, 0, 0, 557, 0, - 557, 0, 0, 0, 0, 0, 3204, 0, 0, 0, - 0, 0, 0, 557, 0, 3086, 0, 806, 557, 0, - 0, 0, 557, 557, 557, 557, 0, 557, 557, 0, - 0, 3098, 0, 0, 0, 2166, 0, 0, 0, 1216, - 0, 2053, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1751, 1420, 1420, 0, 0, - 0, 1815, 0, 0, 0, 1421, 0, 0, 0, 0, - 1203, 1636, 0, 0, 955, 556, 1418, 0, 0, 0, - 1611, 0, 853, 0, 0, 1612, 0, 0, 1613, 0, - 0, 0, 1614, 1615, 1616, 1617, 1618, 1619, 1620, 3149, - 1915, 1916, 1917, 0, 1918, 1919, 1920, 1921, 1922, 1923, - 0, 0, 0, 1621, 2151, 0, 2154, 1622, 0, 1544, - 0, 0, 0, 1623, 0, 0, 0, 2163, 0, 0, - 1624, 0, 0, 0, 0, 1217, 0, 0, 0, 0, - 0, 0, 0, 1545, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1625, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 2204, - 0, 0, 0, 0, 0, 0, 557, 3166, 1637, 0, - 1815, 1638, 1639, 1640, 1218, 1641, 1642, 1643, 1644, 1645, - 1646, 0, 0, 2324, 1219, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 2482, 0, 1220, 0, 2446, 3200, - 0, 0, 0, 1983, 0, 0, 1418, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1204, 0, 0, - 0, 0, 1612, 0, 0, 1613, 0, 0, 1221, 1614, - 1615, 0, 3217, -2058, -2058, -2058, 0, 0, 556, 1420, - 0, 0, 0, 0, 1626, 556, 0, 0, 0, 0, - 0, 0, 2309, 2310, 2312, 2313, 0, 2315, 0, 0, - 1623, 1627, 0, 0, 3041, 0, 1628, 1624, 0, 0, - 0, 0, 0, 0, 0, 0, 1222, 0, 0, 3245, - 1206, 0, 1223, 557, 0, 0, 0, 0, 0, 1629, - 1630, 0, 1595, 0, 1625, 0, 0, 0, 0, 0, - 0, 556, 0, 0, 1631, 0, 556, 1224, 3065, 0, - 0, 0, 1225, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1612, 0, 0, 1613, 1226, 0, 0, 1614, - 1615, 0, 556, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1632, 0, 0, 1633, 0, 0, 0, 0, - 0, 0, 0, 556, 556, 0, 0, 0, 0, 1634, - 1623, 0, 1635, 0, 0, 0, 0, -2058, 0, 0, - 0, 0, 853, 0, 1751, 0, 0, 557, 556, 0, - 0, 0, 0, 1208, 0, 0, 0, 2432, 0, 0, - 0, 1626, 0, 853, 1625, 0, 3318, 0, 1420, 0, - 0, 1109, 1109, 0, 0, 0, 0, 0, 1627, 0, - 0, 0, 0, 1628, 0, 0, 1418, 0, 0, 0, - 556, 1004, 0, 1004, 0, 0, 0, 0, 0, 0, - 557, 0, 0, 0, 0, 0, 2580, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 3098, 0, - 0, 1631, 0, 0, 0, 853, 0, 0, 0, 2801, - 0, 1636, 0, 0, 0, 0, 0, 0, 0, 1241, - 0, 0, 0, 1285, 1290, 0, 1612, 0, 0, 1613, - 0, 0, 0, 1614, 1615, 0, 853, 0, 0, 0, - 0, -2058, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1634, 0, -2058, 0, - 0, 0, 0, -2058, 1623, 0, 0, 0, 0, 0, - 0, -2058, 0, 0, 0, 3217, 1340, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1420, 0, - 0, 0, 0, 0, 1364, 0, 0, 3318, 1625, 0, - 1412, -2058, 0, 1414, 0, 557, 1425, 1428, 1433, 1436, - 0, 0, 0, 0, 0, 0, 0, 0, 1637, 0, - 0, 1638, 1639, 1640, 1751, 1641, 1642, 1643, 1644, 1645, - 1646, 0, 0, 0, 0, 0, 0, 955, 955, 0, - 3318, 955, 0, 0, 0, 0, 1473, 1285, 0, 1949, - 0, 0, 0, 0, 0, 0, 1634, 0, 1636, 0, - 556, 0, 0, 3076, 0, 1612, 0, 1557, 1613, 0, - 0, 0, 1614, 1615, 1616, 1617, 1618, 1619, 1620, 0, - 0, 0, 1751, 0, 0, 0, 1573, 0, 0, 3318, - 0, 0, 0, 1621, 0, -2058, 0, 1583, 1584, 1585, - 0, 1589, 1593, 1623, 0, 0, 0, 0, 0, 0, - 1624, 0, -2058, 557, 0, 0, 557, -2058, 0, 0, - 0, 0, 1979, 0, 0, 0, 955, 0, 0, 0, - 0, 0, 0, 0, 0, 1655, 0, 1625, 0, 0, - 0, 2166, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1473, 1473, 0, -2058, 0, 0, -2058, 0, - 0, 0, 0, 0, 0, 1637, 0, 0, -2058, -2058, - -2058, 0, 1641, 1642, 1643, 1644, 1645, 1646, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 2655, 1698, - 0, 0, 0, 1714, 1719, 0, 0, 0, 3335, 0, - 0, 2669, 2670, 2672, 1109, 1109, 0, 0, 0, 0, - 1634, 0, 0, 0, 0, 0, 2683, 0, 0, 2686, - 0, 0, 0, 0, 0, 0, 0, 2693, 0, 0, - 0, 0, 0, 0, 1626, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 557, 0, - 0, 1627, 557, 557, 557, 0, 1628, 0, 0, 0, - 1285, 0, 0, 0, 0, -2058, 0, 0, 0, 1285, - 0, 0, 1641, 1642, 1643, 1644, 1645, 1646, 0, 1629, - 1630, 557, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1285, 1631, 0, 557, 557, 557, 557, - 557, 557, 557, 557, 557, 557, 0, 0, 0, 0, - 0, 0, -2058, 2730, 2731, 2732, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1368, 1369, 0, 0, 0, - 0, 0, 1632, 0, 0, 1633, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1634, - -46, 0, 1635, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1370, 1371, 0, 0, - 1372, 1373, 1, 0, 0, 0, 0, 0, 0, 1896, - 0, 0, 2, 0, 3, 4, 0, 0, 0, 0, - 1979, 0, 0, 0, 0, 0, 0, 5, 0, 0, - 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, - 0, 7, 0, 0, 0, 0, 2446, 0, 0, -2058, - 0, 0, 0, 0, 0, 8, 1641, 1642, 1643, 1644, - 1645, 1646, 0, 0, 9, 0, 10, 0, 0, 0, - 0, 0, 1433, 0, 1433, 1433, 1374, 1375, 11, 0, - 12, 1636, 0, 2840, 0, 0, 0, 1109, 1109, 0, - 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1109, 0, 0, 14, 15, 16, 0, - 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, - 0, 0, 0, 18, 0, 0, 0, 0, 0, 0, - 0, 19, 0, 20, 21, 0, 0, 0, 0, 0, - 1376, 1377, 1378, 1379, 1380, 1381, 1382, 1383, 22, 0, - 1384, 1385, 23, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3177, 0, 0, 0, 1822, 0, 0, 0, + 0, 0, -1793, 0, 1426, 0, -2061, 0, 0, 0, + 2336, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, -2061, 3211, 0, 0, 0, -2061, 0, + 1549, 1423, 2954, 1548, 0, 0, 0, 2528, 0, 0, + 0, 0, 0, 0, 0, 1550, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3228, 0, 0, + 855, 0, 0, 556, 0, 2662, -2061, 0, 0, -2061, + 556, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, -2061, 1549, -1793, 0, + 0, -2061, 557, 0, 0, 0, 557, 557, -1793, 0, + 557, 0, 1550, 0, 3256, 0, 0, 1359, 0, 0, + 0, 0, 0, 0, 0, 0, 0, -1793, 0, -1793, + -1793, 1641, 0, 0, 0, 0, 556, 557, 0, -2061, + 0, 556, 0, 0, 0, 0, 0, 0, 0, 0, + 1548, 0, 557, 557, 557, 557, 557, 557, 557, 557, + 557, 557, 0, 0, 0, 0, -1793, 556, 0, -1793, + -1793, -1793, 0, 0, 0, 0, 0, 0, 0, 2160, + 0, 2162, 0, 0, 1548, 0, 0, 0, 556, 556, + 0, 2172, 0, 0, 1641, 0, 0, 0, 0, 0, + 0, 0, 1549, 0, 0, 0, 0, 853, 0, 1758, + 0, 0, 0, 0, 556, 0, 0, 1550, 0, 0, + 0, 0, 0, 0, 1426, 0, 0, 0, 853, 0, + 2209, 3329, 0, -2061, 0, 0, 0, 0, 3102, 0, + 0, 0, 0, 0, 0, 0, 1988, 3065, 0, 0, + 0, 1423, 0, 0, 0, 556, 1006, 0, 1006, 0, + 0, 0, 0, 1548, 0, 0, 0, 0, 0, 0, + 0, 0, 2457, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3109, 0, 0, 0, 0, 0, 0, + 853, 0, 0, 0, 0, 0, -2061, 1549, 0, 0, + 0, 1111, 1111, 0, 0, 0, 1548, 0, 0, 0, + 0, 0, 1550, 0, 0, 0, 0, 0, 0, 0, + 0, 853, 0, 0, 0, 0, 0, 0, 2319, 2320, + 2322, 2323, 2324, 0, 0, 0, 0, 0, 0, 0, + -2061, 0, 0, 0, 0, 0, 0, 1648, 1649, 1650, + 1651, 1652, 1653, 0, 0, 0, 0, 0, 0, 0, + 3228, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1246, 0, 0, 1549, 1288, 1295, 0, 0, 0, + 0, 0, 3329, 0, 0, 1359, 0, 0, 0, 1550, + 1359, 0, 0, 0, 0, 0, 0, 0, 557, 0, + 0, 0, 0, -2061, 11, 0, 0, 3192, 1548, 1758, + 1648, 1649, 1650, 1651, 1652, 1653, 0, 0, 0, 0, + 0, 0, 957, 957, 0, 3329, 957, 0, 1345, 0, + 1356, 0, 14, 15, 1956, 0, 0, 1881, 1883, 0, + 0, 0, 0, 0, 0, 556, 1369, 0, 0, 0, + 0, 0, 1417, 0, 0, 1419, 0, 0, 1430, 1433, + 1438, 1441, 2441, 0, 0, 0, 0, 1758, 0, 0, + 0, 0, 0, 0, 3329, 0, 0, 0, 23, 0, + 0, 1549, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1619, 0, 1550, 1620, 1480, 1288, + 0, 1621, 1622, 1623, 1624, 1625, 1626, 1627, 0, 0, + 3259, 957, 0, 0, 0, 1549, 0, 0, 0, 1564, + 0, 0, 1628, 0, 0, 0, 2175, 0, 0, 0, + 1550, 0, 1630, 0, 0, 0, 0, 0, 1580, 1631, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1590, + 1591, 1592, 0, 1596, 1600, 0, 0, 0, 0, 0, + 0, 1619, 0, 0, 1620, 0, 1632, 0, 1621, 1622, + 0, 3236, 0, 0, 0, 0, 0, 0, 2457, 2954, + 0, 0, 0, 0, 0, 0, 0, 1662, 0, 0, + 0, 0, 0, 0, 1549, 0, 0, 0, 0, 1630, + 0, 0, 0, 0, 1480, 1480, -2061, 0, 0, 1550, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 557, 0, 2984, 0, 0, 0, 24, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1637, 0, - 0, 1638, 1639, 1640, -1424, 1641, 1642, 1643, 1644, 1645, - 1646, 0, 0, 0, 2028, 0, 0, 0, 1899, 0, - 0, 0, 2031, 0, 0, 0, 0, 0, 0, 0, - 25, 0, 0, 0, 1386, 1387, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 3020, 3021, 3022, 3023, + 0, 26, 27, 28, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1632, 557, 0, 0, 1549, 0, 557, + 1701, 0, 1881, 1883, 1717, 1722, 0, 0, 0, 0, + 0, 0, 1550, 0, 1359, 1111, 1111, 0, 0, 0, + 0, 0, 0, 1633, 0, 557, 1619, 0, 0, 1620, + 1548, 0, 0, 1621, 1622, 0, 0, 0, 0, 0, + 1634, 0, 0, 0, 0, 1635, 557, 557, 33, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 2808, 35, + 0, 0, 0, 0, 1630, 0, 3387, 0, 1636, 1637, + 0, -2061, 557, 0, 0, 1288, 0, 0, 0, 0, + 0, 37, 0, 1638, 1288, 38, 0, 0, 0, 0, + -2061, 0, 0, 0, 0, 0, 0, 0, 1632, 1549, + 0, 0, 0, 0, 0, 39, 0, -2061, 1288, 0, + 0, 0, -2061, 557, 1550, 0, 0, 0, 40, 0, + 0, 1639, 0, 0, 1640, 0, 0, 0, 0, 43, + 0, 0, 0, 0, 0, 0, 0, 0, 1641, 0, + 0, 1642, 0, 0, 0, 44, 0, 0, 0, 0, + -2061, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2811, 0, 0, 0, 0, -46, 45, + 0, 0, 0, 0, 0, 0, 2667, 0, 0, 0, + 0, 0, 0, 46, 0, 0, 0, 0, 0, 0, + 1, 2682, 2683, 2685, 1903, -2061, 0, 0, 0, 0, + 2, 2954, 3, 4, 0, 1641, 2696, 0, 0, 2699, + 0, 0, -2061, 0, 2704, 5, 0, -2061, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 2077, 0, 0, 0, 0, 0, 2081, 2082, 2083, - 2084, 2085, 2086, 2087, 2088, 1388, 1389, 0, 0, 2097, - 2098, 0, 0, 0, 2109, 0, 0, 0, 2112, 0, - 0, 2120, 2121, 2122, 2123, 2124, 2125, 2126, 2127, 2128, - 0, 0, 2129, 0, 0, 26, 27, 28, 0, 1109, - 0, 1285, 0, 29, 0, 0, 30, 0, 0, 0, + 1643, 0, 0, 8, 0, 0, 0, 0, 0, 0, + 0, 0, 9, 0, 10, -2061, 0, 1438, 0, 1438, + 1438, 0, 0, 0, 0, 0, 11, 0, 12, 0, + 0, 0, 1111, 1111, 0, 0, 1359, 0, 0, 13, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1111, + 0, 0, 0, 0, 14, 15, 16, 0, 0, 0, + 2741, 2742, 2743, 557, 0, 17, 0, -2061, 0, 0, + 1641, 18, 0, 0, 0, 0, 0, 1427, 0, 19, + 0, 20, 21, 0, 0, 0, 0, 0, 0, 0, + 1619, -1808, 0, 1620, 0, 0, 22, 1621, 1622, 0, + 23, 1625, 1626, 1627, 0, 0, 0, 1644, 0, 0, + 1645, 1646, 1647, 0, 1648, 1649, 1650, 1651, 1652, 1653, + 0, 1549, 0, 0, 0, 0, 24, 0, 1630, 0, + 0, 0, 0, 2493, 0, 1631, 1550, 0, 0, 0, + 0, 0, -1427, 0, 0, 0, 0, 0, 0, 0, + 0, 2037, 0, 0, 0, 0, 0, 0, 0, 2040, + 0, 0, 1632, 0, 0, 0, 0, 0, 25, 0, + 0, 0, -2061, 0, -2061, 0, 0, 0, 0, 0, + 0, 1648, 1649, 1650, 1651, 1652, 1653, 0, 0, 0, + 0, -1808, 0, 0, 0, 1656, 0, 0, 2086, 0, + 2851, 0, 0, 0, 2090, 2091, 2092, 2093, 2094, 2095, + 2096, 2097, 0, 0, 0, 0, 2106, 2107, 0, 0, + 0, 2118, 0, 0, 0, 2121, 0, 0, 2129, 2130, + 2131, 2132, 2133, 2134, 2135, 2136, 2137, 0, -1808, 2138, + 0, 1656, 0, 26, 27, 28, 1111, 0, 1288, 0, + 0, 29, 0, -1808, 30, 0, 0, 0, -1808, 1633, + 0, 0, 0, -1808, 0, 0, 0, 2164, 0, 0, + 0, 0, -1808, 0, 0, 1427, 1634, -1808, 0, -2061, + 0, 1635, 0, 0, 0, 31, 1648, 1649, 1650, 1651, + 1652, 1653, 0, 2995, 32, 0, 0, 0, 0, 0, + 0, 1591, 1592, 0, -2061, -2061, 0, 0, 0, -1808, + 33, 0, 0, 0, 0, 0, 0, 34, 0, 1638, + 0, 35, 0, 0, 0, 0, 0, 0, 0, -1808, + 1656, 36, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 37, 0, 0, 0, 38, 0, 0, + 0, 0, 0, 0, 0, 3031, 3032, 3033, 3034, 0, + -2061, 0, 0, 0, 0, 0, 0, 39, 0, 0, + 0, 0, 1656, 0, 1641, 0, 0, 0, -1808, 1656, + 40, -1808, 0, 41, 0, 0, 42, -1808, 0, 0, + 0, 43, 2290, 0, 0, 0, 1288, 0, 0, 2300, + 2301, 0, 0, 0, 0, 0, 0, 44, 0, 0, + 0, 1619, 0, 0, 1620, 0, 0, 0, 1621, 1622, + 1623, 1624, 1625, 1626, 1627, 0, 0, -1808, 0, 1656, + 1619, 45, 0, 1620, 0, 0, 0, 1621, 1622, 1628, + 1288, 1625, 1626, 1627, 0, 46, 0, 0, -46, 1630, + 0, 0, -1808, 1656, 0, 0, 1631, 0, 1628, 1345, + 2365, 0, 0, 0, 0, 0, 0, 0, 1630, 0, + 0, 0, 0, 0, 0, 1631, 1643, 0, 0, 0, + 0, 0, 0, 1632, 0, 0, 0, 0, 2389, 2390, + 0, 2391, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1656, 1632, 1656, 0, 1427, 1427, 3147, 1931, 0, + 855, 1427, 0, 0, 1656, 0, 0, 1656, 0, 0, + 2417, 2418, 1656, 0, 2164, 1656, 0, 0, 1618, 0, + 0, 0, 0, 1619, 0, 0, 1620, 0, -1808, 0, + 1621, 1622, 1623, 1624, 1625, 1626, 1627, 0, -1808, 0, + 0, 0, 0, 2445, 0, 0, 0, 0, 0, 2451, + 0, 1628, 0, 0, 1656, 1629, 0, -1808, 0, -1808, + -1808, 1630, 0, 0, 0, 0, 0, 1480, 1631, 1288, + 1633, 0, 0, 1644, 0, 0, 1645, 1646, 1647, 0, + 1648, 1649, 1650, 1651, 1652, 1653, 0, 1634, 0, 1633, + 0, 0, 1635, 0, 0, 1632, -1808, 0, 0, -1808, + -1808, -1808, 0, 0, 0, 0, 1634, 2486, 0, 0, + 0, 1635, 0, 0, 0, 1636, 1637, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 2155, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 31, 0, 0, - 0, 0, 0, 0, 0, 3225, 32, 0, 0, 0, - 0, 0, 2446, 0, 0, 0, 0, 0, 1584, 1585, - 1390, 1391, 33, 0, 0, 0, 0, 0, 0, 34, - 0, 0, 0, 35, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 36, 1392, 1393, 0, 0, 3136, 0, - 0, 0, 0, 0, 0, 37, 0, 0, 0, 38, - 0, 0, 0, 0, 1996, 0, 0, 0, 557, 1612, - 0, 0, 1613, 557, 0, 0, 1614, 1615, 0, 39, - 1618, 1619, 1620, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 40, 0, 0, 41, 0, 1621, 42, 557, - 0, 0, 0, 43, 0, 2281, 0, 1623, 0, 1285, - 0, 0, 2291, 2292, 1624, 0, 0, 0, 0, 44, - 557, 557, 0, 1612, 0, 0, 1613, 0, 0, 0, - 1614, 1615, 1616, 1617, 1618, 1619, 1620, 0, 0, 0, - 0, 1625, 0, 45, 0, 557, 0, 0, 0, 0, - 1285, 1621, 0, 0, 0, 2781, 0, 46, 0, 0, - -46, 1623, 0, 0, 0, 0, 0, 0, 1624, 0, - 0, 0, 1340, 2356, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 557, 0, 0, - 0, 0, 0, 0, 0, 1625, 0, 0, 0, 0, - 0, 2380, 2381, 0, 2382, 0, 0, 0, 0, 0, - 0, 0, 0, 1612, 0, 0, 1613, 0, 0, 0, - 1614, 1615, 1616, 1617, 1618, 1619, 1620, 0, 0, 0, - 0, 0, 0, 2408, 2409, 0, 0, 2155, 1626, 0, - 0, 1621, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1623, 0, 0, 0, 1627, 0, 0, 1624, 0, - 1628, 0, 0, 0, 0, 0, 2436, 0, 0, 0, - 0, 2441, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1629, 1630, 1625, 0, 0, 1473, 0, - 1285, 0, 1626, 0, 0, 0, 0, 0, 1631, 0, - 0, 0, 0, 0, 0, 0, 0, 1422, 0, 1627, - 0, 1201, 0, 0, 1628, 0, 0, 1202, 0, 0, - 0, 0, 0, 0, 0, 1214, 0, 0, 2475, 0, - 0, 0, 0, 0, 0, 0, 1632, 1629, 1630, 1633, - 0, 0, 0, 0, 0, 1215, 0, 0, 3291, 0, - 0, 0, 1631, 1634, 0, 0, 1635, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 2494, 0, 3316, - 0, 0, 2497, 2498, 0, 0, 0, 557, 0, 0, - 0, 0, 1626, 0, 0, 0, 0, 0, 0, 0, - 1632, 1216, 0, 1633, 0, 0, 0, 0, 0, 1627, - 0, 0, 0, 0, 1628, 0, 0, 1634, 0, 0, - 1635, 0, 0, 0, 0, 0, 2519, 0, 0, 2522, - 0, 2524, 1203, 0, 0, 1649, 0, 1629, 1630, 0, - 0, 3355, 0, 0, 0, 0, 0, 2528, 0, 0, - 0, 0, 1631, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1636, 0, 0, 0, 0, - 0, 0, 3381, 0, 0, 0, 0, 0, 0, 0, - 1649, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1632, 1698, 0, 1633, 0, 0, 0, 1217, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1634, 1719, 2127, - 1635, 0, 0, 0, 0, 0, 1422, 0, 0, 1636, - 0, 0, 0, 0, 0, 0, 0, 1109, 0, 0, - 0, 0, 0, 0, 0, 0, 2584, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1218, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1219, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1649, 1220, 0, - 0, 0, 1637, 0, 0, 1638, 1639, 1640, 0, 1641, - 1642, 1643, 1644, 1645, 1646, 0, 0, 0, 0, 1204, - 0, 0, 0, 1585, 0, 0, 0, 0, 0, 1285, - 1221, 0, 0, 0, 0, 0, 0, 0, 0, 1636, - 0, 1649, 0, 0, 0, 0, 1649, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1637, 0, 0, 1638, - 1639, 1640, 0, 1641, 1642, 1643, 1644, 1645, 1646, 0, - 0, 0, 0, 2068, 0, 0, 0, 0, 2256, 0, - 1612, 0, 1206, 1613, 1223, 2689, 0, 1614, 1615, 1616, - 1617, 1618, 1619, 1620, 0, 0, 1649, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1621, 1224, - 0, 0, 0, 0, 2257, 0, 0, 0, 1623, 0, - 1649, 0, 0, 0, 0, 1624, 0, 0, 1226, 0, - 0, 0, 0, 0, 1367, 0, 819, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1637, 0, 0, 1638, - 1639, 1640, 1625, 1641, 1642, 1643, 1644, 1645, 1646, 0, - 0, 0, 0, 2068, 0, 0, 0, 0, 1649, 0, - 1649, 0, 1422, 1422, 0, 1924, 0, 0, 1422, 0, - 0, 1649, 0, 0, 1649, 1208, 0, 0, 0, 1649, - 0, 0, 1649, 0, 0, 0, 0, 0, 0, 1368, - 1369, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1368, 1369, 0, 0, 0, 0, 0, 2769, - 0, 0, 0, 0, 0, 2771, 2031, 0, 0, 1649, - 0, 0, 0, 0, 0, 0, 2777, 0, 0, 0, - 1370, 1371, 0, 0, 1372, 1373, 0, 2786, 0, 1626, - 2789, 0, 2791, 1370, 1371, 0, 0, 1372, 1373, 0, - 2795, 0, 0, 0, 0, 0, 1627, 0, 2802, 2803, - 0, 1628, 0, 0, 0, 2810, 0, 0, 0, 0, + 1638, 0, 0, 0, 1636, 1637, 0, 0, 1656, 0, + 0, 0, 0, 0, 0, 0, 2505, 0, 0, 1638, + 0, 2508, 2509, 0, 1656, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1656, 1656, 1656, 0, 1639, 0, + 1656, 1640, 0, 0, 1656, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1641, 1619, 1639, 1642, 1620, + 1640, 0, 1633, 1621, 1622, 2530, 0, 0, 2533, 0, + 2535, 0, 0, 0, 1641, 1204, 0, 1642, 0, 1634, + 0, 1205, 0, 0, 1635, 0, 2539, 0, 0, 1217, + 0, 0, 0, 0, 1630, 0, 0, 0, 0, 0, + 0, -2061, 0, 0, 0, 0, 1656, 1636, 1637, 1218, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 2819, 0, 0, 0, 1629, 1630, 0, 0, 0, 0, - 2834, 0, 0, 0, 0, 0, 0, 0, 0, 1631, - 0, 0, 0, 1649, 0, 0, 0, 0, 0, 0, - 1374, 1375, 1109, 0, 0, 0, 0, 0, 0, 1649, - 0, 0, 0, 1374, 1375, 0, 0, 0, 0, 1649, - 1649, 1649, 0, 0, 0, 1649, 0, 1632, 0, 1649, - 1633, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1634, 0, 0, 1635, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 2281, - 0, 2281, 0, 0, 1376, 1377, 1378, 1379, 1380, 1381, - 1382, 1383, 0, 0, 1384, 1385, 0, 1376, 1377, 1378, - 1379, 1380, 1381, 1382, 1383, 0, 0, 1384, 1385, 0, - 0, 1649, 0, 0, 0, 0, 0, 1612, 0, 0, - 1613, 0, 0, 0, 1614, 1615, 1616, 1617, 1618, 1619, - 1620, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1621, 0, 0, 0, 0, - 0, 0, 0, 0, 1649, 1623, 0, 0, 0, 0, - 0, 0, 1624, 0, 0, 0, 1636, 0, 1386, 1387, - 1649, 0, 0, 0, 0, 1649, 3036, 3037, 0, 0, - 0, 1386, 1387, 0, 0, 0, 0, 0, 0, 1625, - 0, 0, 1924, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1388, - 1389, 3060, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1612, 1388, 1389, 1613, 3064, 0, 0, 1614, 1615, - 3066, 3067, 1618, 1619, 1620, 3068, 0, 0, 0, 0, - 3071, 0, 0, 3074, 3075, 0, 0, 0, 2281, 1285, - 0, 0, 3083, 0, 0, 0, 0, 0, 0, 1623, - 0, 0, 0, 1109, 0, 0, 1624, 0, 0, 0, - 0, 0, 0, 1637, 0, 0, 1638, 1639, 1640, 0, - 1641, 1642, 1643, 1644, 1645, 1646, 1626, 0, 0, 0, - 2379, 0, 0, 1625, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1627, 1390, 1391, 0, 3124, 1628, 0, - 0, 0, 0, 0, 0, 0, 0, 1390, 1391, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1392, 1393, - 0, 1629, 1630, 0, 3143, 0, 0, 0, 0, 0, - 0, 1392, 1393, 0, 0, 0, 1631, 0, 0, 0, - 0, 0, 1649, 0, 0, 0, 0, 0, 0, 0, - 1924, 1924, 0, 1422, 1422, 1422, 1422, 1422, 1422, 0, - 0, 1422, 1422, 1422, 1422, 1422, 1422, 1422, 1422, 1422, - 1422, 1924, 0, 0, 1632, 0, 0, 1633, 0, 0, - 1626, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1634, 0, 0, 1635, 0, 0, 1627, 0, 0, - 0, 0, 1628, 0, 0, 0, 0, 1612, 0, 0, - 1613, 0, 0, 3176, 1614, 1615, 1616, 1617, 1618, 1619, - 1620, 0, 0, 0, 0, 1629, 1630, 0, 0, 0, - 0, 0, 0, 0, 0, 1621, 0, 0, 0, 0, - 1631, 0, 0, 0, 0, 1623, 0, 0, 0, 0, - 0, 0, 1624, 0, 0, 0, 0, 0, 0, 0, - 0, 1593, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1649, 0, 0, 1649, 1632, 1625, - 0, 1633, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1636, 2494, 1634, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 3237, 3238, 0, 0, 3239, - 0, 1585, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1649, 0, 0, 0, 1649, 1649, 1649, - 1649, 1649, 1649, 1649, 1649, 0, 3257, 0, 0, 0, - 1422, 1422, 0, 1649, 1649, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1649, 0, 0, 1649, 0, - 3269, 0, 0, 0, 0, 0, 1649, 1649, 1649, 1649, - 1649, 1649, 1649, 1649, 1649, 1649, 1626, 0, 0, 0, + 0, 0, 1638, 0, 0, 0, 1701, 0, 1632, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1627, 0, 0, 0, 1636, 1628, 0, - 1637, 1649, 0, 1638, 1639, 1640, 0, 1641, 1642, 1643, - 1644, 1645, 1646, 0, 0, 0, 0, 2479, 0, 0, - 0, 1629, 1630, 0, 0, 0, 0, 0, 0, 0, - 3314, 0, 0, 0, 0, 0, 1631, 0, 0, 0, - 0, 0, 0, 0, 0, 721, 0, 0, 0, 3036, - 0, 0, 0, 3332, 0, 0, 0, 1109, 1422, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 3341, 0, - 0, 0, 0, 2281, 1632, 2281, 0, 1633, 0, 0, - 0, 0, 0, 1109, 0, 0, 0, 0, 0, 0, - 0, 1634, 0, 0, 1635, 0, 0, 0, 0, 0, - 0, 3366, 722, 0, 1637, 0, 0, 1638, 1639, 1640, - 0, 1641, 1642, 1643, 1644, 1645, 1646, 0, 723, 0, - 0, 0, 0, 0, 0, 0, 0, 1649, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1649, 1649, 0, + 0, 0, 0, 1722, 2136, 1656, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1219, 0, 1643, 0, 0, + 1639, 1656, 1111, 1640, 0, 0, 1656, 3302, 0, 0, + 0, 0, 0, 0, 0, 2595, 1643, 1641, 0, 0, + 1642, 0, 0, 1931, 0, 0, 1206, 0, 3327, 0, + 0, 0, 0, 2812, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 3392, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 3036, 0, 0, 0, 0, 0, 0, 724, 0, 0, - 0, 0, 1109, 0, 0, 0, 0, 725, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 726, 0, 0, 1636, 0, 727, 0, 0, 0, 0, - 0, 0, 1649, 0, 3435, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, -2061, 0, 0, 0, 0, + 0, 0, 1592, 0, 0, 0, 0, 0, 1288, 0, + 0, 0, -2061, 0, 0, 0, 0, -2061, 0, 0, + 3366, 1220, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1644, 0, 0, 1645, 1646, 1647, + 0, 1648, 1649, 1650, 1651, 1652, 1653, 0, 0, 1643, + 0, 3392, 0, 1644, 1906, -2061, 1645, 1646, 1647, 0, + 1648, 1649, 1650, 1651, 1652, 1653, 0, 2702, 0, 0, + 1221, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1222, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1223, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 728, 0, 1649, 1649, 1649, 0, - 0, 1924, 1924, 1924, 1924, 1924, 1924, 0, 0, 0, - 1924, 1924, 1924, 1924, 1924, 1924, 1924, 1924, 1924, 1924, - 1612, 0, 0, 1613, 1649, 1649, 0, 1614, 1615, 1616, - 1617, 1618, 1619, 1620, 0, 0, 0, 729, 0, 0, - 0, 730, 0, 0, 0, 0, 0, 0, 1621, 0, - 0, 0, 1649, 0, 0, 0, 0, 1649, 1623, 0, - 0, 0, 3489, 3489, 3489, 1624, 0, 0, 0, 0, - 1637, 0, 0, 1638, 1639, 1640, 0, 1641, 1642, 1643, - 1644, 1645, 1646, 0, 0, 0, 0, 2503, 0, 3489, - 0, 1649, 1625, 0, 0, 0, 0, 0, 0, 0, + 1641, 0, 0, 1207, 0, 0, 0, 1656, 0, 0, + 0, 0, 0, 0, 1224, 1931, 1931, 0, 1427, 1427, + 1427, 1427, 1427, 1427, 0, 0, 1427, 1427, 1427, 1427, + 1427, 1427, 1427, 1427, 1427, 1427, 1931, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1644, 0, 0, 1645, + 1646, 1647, 0, 1648, 1649, 1650, 1651, 1652, 1653, 0, + 0, 0, 2265, 0, 0, 0, 1209, 0, 1226, 0, + 0, 0, 0, 0, 0, 1619, 0, 0, 1620, 0, + 0, 0, 1621, 1622, 1623, 1624, 1625, 1626, 1627, 0, + 2780, 0, 0, 1227, 0, 0, 2782, 2040, 2266, 0, + 0, 0, -2061, 1628, 0, 0, 0, 2788, 0, 0, + 0, 0, 1229, 1630, 0, 0, 0, 0, 2797, 0, + 1631, 2800, 0, 2802, 0, 0, 0, 0, 0, 0, + 0, 2806, 0, 0, 0, 0, 0, 0, 0, 2813, + 2814, 1656, 0, 0, 1656, 0, 2821, 1632, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1649, 731, 0, 1649, 1649, 0, 0, 0, 0, 0, - 0, 1924, 1924, 0, 0, 0, 732, 0, 0, 0, - 3489, 0, 0, 0, 0, 1649, 1422, 1422, 1649, 0, - 1649, 0, 0, 0, 1649, 0, 1612, 0, 0, 1613, - 0, 0, 0, 1614, 1615, 1616, 1617, 1618, 1619, 1620, - 0, 733, 0, 0, 734, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1621, 735, 0, 0, 736, 0, - 0, 0, 0, 0, 1623, 0, 0, 0, 0, 1626, - 0, 1624, 0, 0, 0, 0, 737, 0, 0, 0, - 1649, 0, 0, 0, 0, 0, 1627, 0, 0, 0, - 738, 1628, 0, 1612, 0, 0, 1613, 740, 1625, 0, - 1614, 1615, 1616, 1617, 1618, 1619, 1620, 741, 0, 0, - 0, 0, 0, 742, 1629, 1630, 0, 0, 0, 0, - 0, 1621, 0, 0, 0, 0, 0, 0, 0, 1631, - 0, 1623, 0, 0, 0, 0, 0, 0, 1624, 0, - 743, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 2830, 0, 0, 0, 0, 0, 0, 0, 1211, + 0, 2845, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1625, 0, 1632, 0, 0, - 1633, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1634, 1649, 0, 1635, 0, 0, - 0, 0, 0, 0, 0, 1626, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1422, - 0, 0, 1627, 0, 0, 0, 0, 1628, 0, 0, - 0, 0, 0, 0, 0, 1612, 0, 0, 1613, 0, - 0, 0, 1614, 1615, 1616, 1617, 1618, 1619, 1620, 0, - 1629, 1630, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1621, 0, 1631, 0, 0, 2175, 0, - 0, 0, 1626, 1623, 0, 1649, 0, 1649, 0, 0, - 1624, 0, 0, 1649, 0, 0, 0, 0, 0, 1627, - 0, 0, 1649, 0, 1628, 1649, 1636, 1649, 0, 0, - 0, 1649, 0, 1632, 1924, 1924, 1633, 1625, 1649, 1649, - 0, 0, 0, 0, 0, 0, 1649, 1629, 1630, 0, - 1634, 0, 0, 1635, 0, 1649, 0, 0, 0, 0, + 1656, 1111, 0, 0, 1656, 1656, 1656, 1656, 1656, 1656, + 1656, 1656, 0, 0, 0, 0, 0, 1427, 1427, -2061, + 1656, 1656, 0, 0, 0, 0, 1648, 1649, 1650, 1651, + 1652, 1653, 1656, 0, 0, 1656, 0, 0, 0, 0, + 0, 0, 0, 1656, 1656, 1656, 1656, 1656, 1656, 1656, + 1656, 1656, 1656, 0, 1633, 0, 0, 0, 0, 0, + 2290, 0, 2290, 0, 0, 0, 0, 0, 0, 0, + 0, 1634, 0, 0, 0, 0, 1635, 1619, 1656, 0, + 1620, 0, 0, 0, 1621, 1622, 1623, 1624, 1625, 1626, + 1627, 0, 0, 0, 0, 0, 0, 0, 0, 1636, + 1637, 0, 0, 0, 0, 1628, 0, 0, 0, 2792, + 0, 0, 0, 0, 1638, 1630, 0, 0, 0, 0, 0, 0, 1631, 0, 0, 0, 0, 0, 0, 0, - 1649, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 2176, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 721, 0, 0, 0, - 1632, 0, 0, 1633, 0, 0, 0, 0, 1422, 0, - 0, 0, 0, 0, 0, 0, 0, 1634, 0, 0, - 1635, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1637, 1626, 0, 1638, 1639, 1640, 0, - 1641, 1642, 1643, 1644, 1645, 1646, 0, 0, 0, 0, - 2711, 1627, 1636, 722, 0, 0, 1628, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 723, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1629, - 1630, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1631, 0, 0, 0, 0, 0, + 0, 1427, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1632, + 0, 0, 1639, 0, 0, 1640, 0, 3047, 3048, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1641, + 0, 0, 1642, 0, 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, 1636, - 0, 0, 0, 0, 0, 0, 0, 0, 725, 0, - 0, 0, 1632, 0, 0, 1633, 0, 0, 0, 0, - 0, 726, 0, 0, 0, 0, 727, 1924, 1422, 1634, - 0, 0, 1635, 0, 0, 0, 0, 0, 0, 1637, - 0, 0, 1638, 1639, 1640, 0, 1641, 1642, 1643, 1644, - 1645, 1646, 1649, 1649, 0, 728, 2783, 0, 0, 0, + 0, 0, 3071, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1656, 0, 3075, 0, 0, 0, + 0, 3077, 3078, 0, 1656, 1656, 3079, 0, 0, 0, + 0, 3082, 0, 0, 3085, 3086, 0, 0, 0, 2290, + 1288, 0, 0, 3094, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1111, 0, 1633, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1649, 0, 0, 0, - 1649, 0, 1649, 1649, 1649, 0, 0, 1649, 0, 0, - 1649, 1649, 0, 0, 0, 0, 0, 0, 729, 1649, - 0, 0, 730, 0, 0, 0, 1637, 0, 0, 1638, - 1639, 1640, 0, 1641, 1642, 1643, 1644, 1645, 1646, 0, - 0, 0, 0, 2850, 0, 0, 0, 0, 0, 0, - 0, 1636, 0, 0, 0, 0, 0, 0, 0, 0, - 1649, 0, 0, 0, 0, 0, 1924, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1649, - 0, 0, 0, 0, 0, 0, 543, 0, 0, 0, - 0, 0, 731, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 732, 0, 0, - 0, 0, 1649, 0, 2179, 0, 0, 0, 0, 0, + 0, 0, 0, 1634, 0, 0, 0, 0, 1635, 0, + 0, 1643, 0, 0, 0, 0, 0, 0, 0, 1656, + 0, 0, 0, 0, 0, 0, 0, 0, 3135, 0, + 0, 1636, 1637, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1656, 1656, 1656, 1638, 0, 1931, 1931, + 1931, 1931, 1931, 1931, 0, 3154, 0, 1931, 1931, 1931, + 1931, 1931, 1931, 1931, 1931, 1931, 1931, 0, 0, 0, + 0, 1656, 1656, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1639, 0, 0, 1640, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1656, + 0, 1641, 0, 0, 1642, 1656, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1644, 0, + 0, 1645, 1646, 1647, 0, 1648, 1649, 1650, 1651, 1652, + 1653, 0, 0, 0, 0, 2077, 0, 0, 0, 0, + 1656, 0, 0, 0, 0, 3188, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1656, + 0, 1619, 1656, 1656, 1620, 0, 0, 0, 1621, 1622, + 1931, 1931, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1656, 1427, 1427, 1656, 0, 1656, + 0, 0, 1600, 1656, 0, 0, 0, 0, 0, 1630, + 0, 0, 0, 1643, 0, 0, -2061, 0, 0, 0, + 1619, 0, 0, 1620, 0, 0, 0, 1621, 1622, 1623, + 1624, 1625, 1626, 1627, 0, 2505, 0, 0, 0, 0, + 0, 0, 0, 1632, 0, 0, 3248, 3249, 1628, 0, + 3250, 0, 1592, 0, 0, 0, 0, 0, 1630, 1656, + 0, 0, 0, 0, 0, 1631, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3268, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1632, 0, 0, 0, 0, 0, 0, 0, + 0, 3280, 0, 0, 0, 0, 0, 0, 3087, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1924, 0, 733, 0, 0, 734, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 735, 0, 1637, 736, - 0, 1638, 1639, 1640, 0, 1641, 1642, 1643, 1644, 1645, - 1646, 0, 0, 1649, 1649, 1649, 0, 737, 0, 0, + 1644, 0, 0, 1645, 1646, 1647, 0, 1648, 1649, 1650, + 1651, 1652, 1653, 0, 0, 0, 0, 2077, 0, 0, + -2061, 1619, 0, 0, 1620, 0, 0, 0, 1621, 1622, + 1623, 1624, 1625, 1626, 1627, 0, 0, -2061, 0, 0, + 0, 0, -2061, 0, 0, 0, 1656, 0, 0, 1628, + 0, 0, 3326, 0, 0, 0, 0, 0, 0, 1630, + 0, 0, 0, 0, 0, 0, 1631, 0, 1427, 1633, + 3047, 0, 0, 0, 3343, 0, 0, 0, 1111, 0, + -2061, 0, 0, 0, 0, 0, 1634, 0, 0, 3352, + 0, 1635, 0, 1632, 2290, 0, 2290, 0, 0, 0, + 0, 0, 0, 0, 1111, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1636, 1637, 0, 0, 0, 0, + 0, 0, 3377, 0, 1656, 0, 1656, 0, 0, 1638, + 0, 0, 1656, 0, 0, 1641, 0, 0, 0, 0, + 0, 1656, 0, 0, 1656, 0, 1656, 0, 0, 0, + 1656, 0, 0, 1931, 1931, 0, 1619, 1656, 1656, 1620, + 0, 0, 0, 1621, 1622, 1656, 0, 1639, 0, 0, + 1640, 3403, 0, 0, 1656, 0, 0, 0, 0, 0, + 0, 3047, 0, 0, 1641, 0, 0, 1642, 0, 1656, + 1633, 0, 0, 1111, 1630, 0, 0, 0, 0, 0, + 0, -2061, 0, 0, 0, 0, 0, 1634, 0, 0, + 0, 0, 1635, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3446, 0, 1427, 1632, 0, + 0, 0, 0, 0, 0, 1636, 1637, -2061, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 738, 0, 1649, 0, 0, 0, 739, 740, 0, - 0, 0, 0, 0, 0, 1649, 0, 0, 741, 0, - 0, 0, 0, 0, 742, 0, 0, 0, 0, 0, + 1638, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1619, 0, 0, 1620, + 0, 0, 0, 1621, 1622, 1623, 1624, 1625, 1626, 1627, + 0, 0, 0, 0, 0, 0, 1643, 0, 1639, 0, + 0, 1640, 0, 0, 1628, 0, 0, 0, 0, 2180, + 0, 0, 0, 0, 1630, 1641, 0, 0, 1642, 0, + 0, 1631, 0, 3500, 3500, 3500, 0, 0, 0, 0, + 0, 0, 0, 0, 0, -2061, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1632, 0, + 3500, 0, -2061, 0, -2061, 0, 0, -2061, 0, 0, + 0, 1648, 1649, 1650, 1651, 1652, 1653, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1931, 1427, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3500, 0, 0, 2181, -2061, 0, 0, 0, 0, + 0, 1656, 1656, 1644, 0, 0, 1645, 1646, 1647, 0, + 1648, 1649, 1650, 1651, 1652, 1653, 0, 1643, 0, 0, + 2388, 0, 0, 0, 0, 1656, 0, 0, 0, 1656, + 0, 1656, 1656, 1656, 0, 0, 1656, 0, 0, 1656, + 1656, 0, 0, 0, 0, 1633, 0, 0, 1656, 0, + 1641, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1634, 0, 0, 0, 0, 1635, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 743, 0, 0, 0, 0, 0, 0, 0, 0, - 1649, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1649, 0, - 0, 0, 0, 0, 0, 0, 0, 1649, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1656, + 1636, 1637, 0, 0, 0, 1931, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1638, 0, 0, 1656, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1644, 0, 0, 1645, 1646, 1647, + 0, 1648, 1649, 1650, 1651, 1652, 1653, 0, 0, 0, + 0, 2490, 1656, 1639, 0, 0, 1640, 0, 0, 0, + 0, 0, -2061, 0, 0, 0, 0, 0, 0, 0, + 1641, 0, 0, 1642, 0, 0, 0, 0, 0, 1931, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1649, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1649, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1656, 1656, 1656, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 117, 1044, 819, 1045, 1046, 1047, - 1048, 1049, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1649, 0, 118, 119, 120, 121, 122, 123, 124, - 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, - 1050, 0, 0, 129, 130, 131, 0, 132, 133, 134, - 135, 136, 137, 138, 139, 1051, 141, 1052, 1053, 0, - 144, 145, 146, 147, 148, 149, 1054, 789, 150, 151, - 152, 153, 1055, 1056, 156, 1649, 157, 158, 159, 160, - 790, 0, 791, 0, 1057, 164, 165, 166, 167, 168, - 169, 170, 171, 172, 0, 173, 174, 175, 176, 177, - 178, 0, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 1058, 191, 192, 1059, 194, 1060, 195, - 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, - 203, 204, 205, 0, 0, 206, 207, 1061, 209, 210, - 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, - 218, 219, 220, 1062, 222, 223, 224, 225, 226, 227, - 792, 1063, 229, 0, 230, 231, 1064, 233, 0, 234, - 0, 235, 236, 0, 237, 238, 239, 240, 241, 242, - 0, 243, 0, 1065, 1066, 246, 247, 0, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, - 268, 269, 270, 271, 272, 273, 274, 1067, 1068, 0, - 1069, 0, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 0, 0, 289, 290, 291, 292, 0, - 293, 294, 295, 296, 297, 298, 299, 300, 1070, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 1071, - 323, 1072, 325, 326, 327, 328, 1073, 329, 330, 331, - 332, 1074, 794, 334, 1075, 336, 337, 338, 0, 339, - 340, 0, 0, 1076, 342, 343, 0, 0, 344, 345, - 346, 347, 348, 349, 796, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, - 362, 363, 797, 365, 366, 367, 368, 369, 370, 371, - 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, - 380, 381, 382, 1077, 384, 385, 386, 387, 0, 388, - 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, - 399, 400, 0, 401, 402, 403, 404, 405, 406, 1078, - 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, - 426, 427, 428, 429, 0, 430, 431, 432, 1079, 434, - 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, - 444, 445, 446, 447, 448, 799, 0, 0, 450, 451, - 0, 452, 453, 454, 455, 456, 457, 458, 0, 459, - 1080, 1081, 0, 0, 462, 463, 800, 465, 801, 1082, - 467, 468, 802, 470, 471, 472, 473, 474, 0, 0, - 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, - 483, 484, 485, 486, 487, 1083, 0, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, - 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, - 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, - 518, 519, 1084, 0, 0, 0, 0, 0, 0, 1085, - 1086, 1087, 0, 0, 0, 0, 1088, 0, 1089, 0, - 0, 0, 0, 1090, 1091, 0, 1092, 1093, 2636, 117, - 1044, 819, 1045, 1046, 1047, 1048, 1049, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, - 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, - 0, 0, 0, 0, 0, 1050, 0, 0, 129, 130, - 131, 0, 132, 133, 134, 135, 136, 137, 138, 139, - 1051, 141, 1052, 1053, 0, 144, 145, 146, 147, 148, - 149, 1054, 789, 150, 151, 152, 153, 1055, 1056, 156, - 0, 157, 158, 159, 160, 790, 0, 791, 0, 1057, - 164, 165, 166, 167, 168, 169, 170, 171, 172, 0, - 173, 174, 175, 176, 177, 178, 0, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 189, 1058, 191, - 192, 1059, 194, 1060, 195, 0, 196, 197, 198, 199, - 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, - 206, 207, 1061, 209, 210, 0, 211, 212, 213, 0, - 214, 215, 216, 0, 217, 218, 219, 220, 1062, 222, - 223, 224, 225, 226, 227, 792, 1063, 229, 0, 230, - 231, 1064, 233, 0, 234, 0, 235, 236, 0, 237, - 238, 239, 240, 241, 242, 0, 243, 0, 1065, 1066, - 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 0, 260, 261, 262, 263, - 264, 265, 266, 0, 267, 268, 269, 270, 271, 272, - 273, 274, 1067, 1068, 0, 1069, 0, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 287, 288, 0, 0, - 289, 290, 291, 292, 0, 293, 294, 295, 296, 297, - 298, 299, 300, 1070, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, 321, 1071, 323, 1072, 325, 326, 327, - 328, 1073, 329, 330, 331, 332, 1074, 794, 334, 1075, - 336, 337, 338, 0, 339, 340, 0, 0, 1076, 342, - 343, 0, 0, 344, 345, 346, 347, 348, 349, 796, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - 361, 0, 0, 0, 0, 362, 363, 797, 365, 366, - 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, - 376, 377, 0, 378, 379, 380, 381, 382, 1077, 384, - 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, - 403, 404, 405, 406, 1078, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, - 421, 422, 423, 424, 425, 426, 427, 428, 429, 0, - 430, 431, 432, 1079, 434, 0, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, - 799, 0, 0, 450, 451, 0, 452, 453, 454, 455, - 456, 457, 458, 0, 459, 1080, 1081, 0, 0, 462, - 463, 800, 465, 801, 1082, 467, 468, 802, 470, 471, - 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, - 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, - 1083, 0, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 516, 517, 518, 519, 1084, 0, 0, - 0, 0, 0, 0, 1085, 1086, 1087, 0, 0, 0, - 0, 1088, 0, 1089, 0, 0, 0, 0, 1090, 1091, - 0, 1092, 1093, 3240, 117, 1044, 819, 1045, 1046, 1047, - 1048, 1049, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, - 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, - 1050, 0, 0, 129, 130, 131, 0, 132, 133, 134, - 135, 136, 137, 138, 139, 1051, 141, 1052, 1053, 0, - 144, 145, 146, 147, 148, 149, 1054, 789, 150, 151, - 152, 153, 1055, 1056, 156, 0, 157, 158, 159, 160, - 790, 0, 791, 0, 1057, 164, 165, 166, 167, 168, - 169, 170, 171, 172, 0, 173, 174, 175, 176, 177, - 178, 0, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 1058, 191, 192, 1059, 194, 1060, 195, - 0, 196, 197, 198, 199, 200, 201, 14, 15, 202, - 203, 204, 205, 0, 0, 206, 207, 1061, 209, 210, - 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, - 218, 219, 220, 1062, 222, 223, 224, 225, 226, 227, - 792, 1063, 229, 0, 230, 231, 1064, 233, 0, 234, - 0, 235, 236, 23, 237, 238, 239, 240, 241, 242, - 0, 243, 0, 1065, 1066, 246, 247, 0, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, - 268, 269, 270, 271, 272, 273, 274, 1067, 1068, 0, - 1069, 0, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 0, 0, 289, 290, 291, 292, 0, - 293, 294, 295, 296, 297, 298, 299, 300, 1070, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 1071, - 323, 1072, 325, 326, 327, 328, 1073, 329, 330, 331, - 332, 1074, 794, 334, 1075, 336, 337, 338, 0, 339, - 340, 0, 0, 1076, 342, 343, 0, 0, 344, 345, - 346, 347, 348, 349, 796, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, 361, 26, 27, 28, 0, - 362, 363, 797, 365, 366, 367, 368, 369, 370, 371, - 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, - 380, 381, 382, 1077, 384, 385, 386, 387, 0, 388, - 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, - 399, 400, 0, 401, 402, 403, 404, 405, 406, 1078, - 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 33, 0, 421, 422, 423, 424, 425, - 426, 427, 428, 429, 35, 430, 431, 432, 1079, 434, - 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, - 444, 445, 446, 447, 448, 799, 37, 0, 450, 451, - 38, 452, 453, 454, 455, 456, 457, 458, 0, 459, - 1080, 1081, 0, 0, 462, 463, 800, 465, 801, 1082, - 467, 468, 802, 470, 471, 472, 473, 474, 0, 0, - 475, 476, 477, 40, 478, 479, 480, 481, 0, 482, - 483, 484, 485, 486, 803, 1083, 0, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, - 44, 499, 500, 501, 502, 503, 504, 505, 506, 507, - 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, - 518, 519, 1084, 0, 45, 0, 0, 0, 0, 1085, - 1086, 1087, 0, 0, 0, 0, 1088, 0, 1089, 3215, - 0, 0, 0, 1090, 1091, 0, 1092, 1093, 117, 1044, - 819, 1045, 1046, 1047, 1048, 1049, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, - 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, - 0, 0, 0, 0, 1050, 0, 0, 129, 130, 131, - 0, 132, 133, 134, 135, 136, 137, 138, 139, 1051, - 141, 1052, 1053, 0, 144, 145, 146, 147, 148, 149, - 1054, 789, 150, 151, 152, 153, 1055, 1056, 156, 0, - 157, 158, 159, 160, 790, 0, 791, 0, 1057, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 0, 173, - 174, 175, 176, 177, 178, 0, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 1058, 191, 192, - 1059, 194, 1060, 195, 0, 196, 197, 198, 199, 200, - 201, 14, 15, 202, 203, 204, 205, 0, 0, 206, - 207, 1061, 209, 210, 0, 211, 212, 213, 0, 214, - 215, 216, 0, 217, 218, 219, 220, 1062, 222, 223, - 224, 225, 226, 227, 792, 1063, 229, 0, 230, 231, - 1064, 233, 0, 234, 0, 235, 236, 23, 237, 238, - 239, 240, 241, 242, 0, 243, 0, 1065, 1066, 246, - 247, 0, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, - 265, 266, 0, 267, 268, 269, 270, 271, 272, 273, - 274, 1067, 1068, 0, 1069, 0, 278, 279, 280, 281, - 282, 283, 284, 285, 286, 287, 288, 0, 0, 289, - 290, 291, 292, 0, 293, 294, 295, 296, 297, 298, - 299, 300, 1070, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 1071, 323, 1072, 325, 326, 327, 328, - 1073, 329, 330, 331, 332, 1074, 794, 334, 1075, 336, - 337, 338, 0, 339, 340, 0, 0, 1076, 342, 343, - 0, 0, 344, 345, 346, 347, 348, 349, 796, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, - 26, 27, 28, 0, 362, 363, 797, 365, 366, 367, - 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, - 377, 0, 378, 379, 380, 381, 382, 1077, 384, 385, - 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 397, 398, 399, 400, 0, 401, 402, 403, - 404, 405, 406, 1078, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 417, 418, 419, 420, 33, 0, 421, - 422, 423, 424, 425, 426, 427, 428, 429, 35, 430, - 431, 432, 1079, 434, 0, 435, 436, 437, 438, 439, - 440, 441, 442, 443, 444, 445, 446, 447, 448, 799, - 37, 0, 450, 451, 38, 452, 453, 454, 455, 456, - 457, 458, 0, 459, 1080, 1081, 0, 0, 462, 463, - 800, 465, 801, 1082, 467, 468, 802, 470, 471, 472, - 473, 474, 0, 0, 475, 476, 477, 40, 478, 479, - 480, 481, 0, 482, 483, 484, 485, 486, 803, 1083, - 0, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 0, 0, 498, 0, 44, 499, 500, 501, 502, 503, - 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, - 514, 515, 516, 517, 518, 519, 1084, 0, 45, 0, - 0, 0, 0, 1085, 1086, 1087, 0, 0, 0, 0, - 1088, 0, 1089, 0, 0, 0, 0, 1090, 1091, 0, - 1092, 1093, 117, 1044, 819, 1045, 1046, 1047, 1048, 1049, + 0, 0, 1656, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1656, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, - 126, 127, 128, 0, 0, 0, 0, 0, 1050, 0, - 0, 129, 130, 131, 0, 132, 133, 134, 135, 136, - 137, 138, 139, 1051, 141, 1052, 1053, 0, 144, 145, - 146, 147, 148, 149, 1054, 789, 150, 151, 152, 153, - 1055, 1056, 156, 0, 157, 158, 159, 160, 790, 0, - 791, 0, 1057, 164, 165, 166, 167, 168, 169, 170, - 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, - 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 189, 1058, 191, 192, 1059, 194, 1060, 195, 0, 196, - 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, - 205, 0, 0, 206, 207, 1061, 209, 210, 0, 211, - 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, - 220, 1062, 222, 223, 224, 225, 226, 227, 792, 1063, - 229, 0, 230, 231, 1064, 233, 0, 234, 0, 235, - 236, 23, 237, 238, 239, 240, 241, 242, 0, 243, - 0, 1065, 1066, 246, 247, 0, 248, 249, 250, 251, - 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, - 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, - 270, 271, 272, 273, 274, 1067, 1068, 0, 1069, 0, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 0, 0, 289, 290, 291, 292, 0, 293, 294, - 295, 296, 297, 298, 299, 300, 1070, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 1071, 323, 1072, - 325, 326, 327, 328, 1073, 329, 330, 331, 332, 1074, - 794, 334, 1075, 336, 337, 338, 0, 339, 340, 0, - 0, 1076, 342, 343, 0, 0, 344, 345, 346, 347, - 348, 349, 796, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, 361, 26, 27, 28, 0, 362, 363, - 797, 365, 366, 367, 368, 369, 370, 371, 0, 372, - 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, - 382, 1077, 384, 385, 386, 387, 0, 388, 389, 390, - 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, - 0, 401, 402, 403, 404, 405, 406, 1078, 408, 409, - 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, - 420, 33, 0, 421, 422, 423, 424, 425, 426, 427, - 428, 429, 0, 430, 431, 432, 1079, 434, 0, 435, - 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, - 446, 447, 448, 799, 0, 0, 450, 451, 38, 452, - 453, 454, 455, 456, 457, 458, 0, 459, 1080, 1081, - 0, 0, 462, 463, 800, 465, 801, 1082, 467, 468, - 802, 470, 471, 472, 473, 474, 0, 0, 475, 476, - 477, 40, 478, 479, 480, 481, 0, 482, 483, 484, - 485, 486, 803, 1083, 0, 489, 490, 491, 492, 493, - 494, 495, 496, 497, 0, 0, 498, 0, 44, 499, - 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, - 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, - 1084, 0, 45, 0, 0, 0, 0, 1085, 1086, 1087, - 0, 0, 0, 0, 1088, 0, 1089, 0, 0, 0, - 0, 1090, 1091, 0, 1092, 1093, 1246, 1044, 819, 1045, - 1046, 1047, 1048, 1049, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 1247, 126, 127, 128, 0, 0, 0, - 1248, 0, 1050, 0, 0, 1249, 130, 131, 0, 132, - 133, 134, 1250, 136, 137, 138, 139, 1051, 1251, 1052, - 1053, 0, 144, 145, 146, 147, 148, 149, 1054, 789, - 150, 151, 152, 153, 1055, 1056, 156, 0, 157, 158, - 159, 160, 790, 0, 1252, 0, 1253, 164, 165, 166, - 167, 168, 1254, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 1255, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 1058, 191, 192, 1059, 194, - 1060, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 1256, 0, 206, 207, 1061, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 1062, 222, 223, 224, 225, - 226, 227, 792, 1063, 229, 0, 230, 231, 1064, 233, - 0, 234, 0, 235, 1257, 0, 1258, 238, 239, 1259, - 1260, 242, 0, 243, 0, 1065, 1066, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 1261, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 1262, 269, 270, 271, 272, 273, 274, 1067, - 1068, 0, 1069, 0, 278, 1263, 1264, 281, 1265, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 1266, 291, - 1267, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 1268, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 1071, 1269, 1072, 325, 326, 327, 328, 1073, 329, - 330, 1270, 332, 1074, 794, 334, 1075, 336, 337, 338, - 0, 339, 340, 0, 0, 1076, 342, 343, 0, 0, - 344, 345, 346, 1271, 348, 1272, 796, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 797, 1273, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 1077, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 1274, 404, 405, - 406, 1078, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 1275, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 1276, 431, 432, - 1079, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 1277, 448, 799, 0, 0, - 450, 451, 0, 452, 1278, 454, 455, 456, 457, 458, - 0, 459, 1080, 1081, 0, 0, 462, 463, 800, 465, - 801, 1082, 467, 468, 1279, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 1083, 1280, 489, - 1281, 491, 492, 493, 494, 495, 496, 497, 0, 0, - 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 1084, 0, 0, 0, 0, 0, - 0, 1085, 1086, 1087, 0, 0, 0, 0, 1088, 0, - 1089, 1282, 0, 0, 0, 1090, 1091, 0, 1092, 1093, - 117, 1044, 819, 1045, 1046, 0, 1048, 1049, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, - 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, - 128, 0, 0, 0, 0, 0, 1050, 0, 0, 129, - 130, 131, 0, 132, 133, 134, 135, 136, 137, 138, - 139, 1051, 141, 1052, 1053, 0, 144, 145, 146, 147, - 148, 149, 1054, 789, 150, 151, 152, 153, 1055, 1056, - 156, 0, 157, 158, 159, 160, 790, 0, 791, 0, - 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, - 0, 173, 174, 175, 176, 177, 178, 0, 179, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 1058, - 191, 192, 1059, 194, 0, 195, 0, 196, 197, 198, - 199, 200, 201, 14, 15, 202, 203, 204, 205, 0, - 0, 206, 207, 1061, 209, 210, 0, 211, 212, 213, - 0, 214, 215, 216, 0, 217, 218, 219, 220, 1062, - 222, 223, 224, 225, 226, 227, 792, 1063, 229, 0, - 230, 231, 1064, 233, 0, 234, 0, 235, 236, 23, - 237, 238, 239, 240, 241, 242, 0, 243, 0, 1065, - 1066, 246, 247, 0, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 0, 260, 261, 262, - 263, 264, 265, 266, 0, 267, 268, 269, 270, 271, - 272, 273, 274, 1067, 1068, 0, 1069, 0, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 0, - 0, 289, 290, 291, 292, 0, 293, 294, 295, 296, - 297, 298, 299, 300, 1070, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 1071, 323, 1072, 325, 326, - 327, 328, 0, 329, 330, 331, 332, 1074, 794, 334, - 1075, 336, 337, 338, 0, 339, 340, 0, 0, 341, - 342, 343, 0, 0, 344, 345, 346, 347, 348, 349, - 796, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, 361, 26, 27, 28, 0, 362, 363, 797, 365, - 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, - 375, 376, 377, 0, 378, 379, 380, 381, 382, 1077, - 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, - 402, 403, 404, 405, 406, 1078, 408, 409, 410, 411, - 412, 413, 414, 415, 416, 417, 418, 419, 420, 33, - 0, 421, 422, 423, 424, 425, 426, 427, 428, 429, - 35, 430, 431, 432, 1079, 434, 0, 435, 436, 437, - 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, - 448, 799, 37, 0, 450, 451, 38, 452, 453, 454, - 455, 456, 457, 458, 0, 459, 1080, 1081, 0, 0, - 462, 463, 800, 465, 801, 1082, 467, 468, 802, 470, - 471, 472, 473, 474, 0, 0, 475, 476, 477, 40, - 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, - 803, 1083, 0, 489, 490, 491, 492, 493, 494, 495, - 496, 497, 0, 0, 498, 0, 44, 499, 500, 501, - 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, - 512, 513, 514, 515, 516, 517, 518, 519, 0, 0, - 45, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1088, 0, 1089, 0, 0, 0, 0, 1090, - 1091, 0, 1092, 1093, 117, 1044, 819, 1045, 1046, 1047, - 1048, 1049, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, - 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, - 1050, 0, 0, 129, 130, 131, 0, 132, 133, 134, - 135, 136, 137, 138, 139, 1051, 141, 1052, 1053, 1429, - 144, 145, 146, 147, 148, 149, 1054, 789, 150, 151, - 152, 153, 1055, 1056, 156, 0, 157, 158, 159, 160, - 790, 0, 791, 0, 1057, 164, 165, 166, 167, 168, - 169, 170, 171, 172, 0, 173, 174, 175, 176, 177, - 178, 0, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 1058, 191, 192, 1059, 194, 1060, 195, - 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, - 203, 204, 205, 0, 0, 206, 207, 1061, 209, 210, - 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, - 218, 219, 220, 1062, 222, 223, 224, 225, 226, 227, - 792, 1063, 229, 0, 230, 231, 1064, 233, 0, 234, - 0, 235, 236, 1430, 237, 238, 239, 240, 241, 242, - 0, 243, 0, 1065, 1066, 246, 247, 0, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, - 268, 269, 270, 271, 272, 273, 274, 1067, 1068, 0, - 1069, 0, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 0, 1431, 289, 290, 291, 292, 0, - 293, 294, 295, 296, 297, 298, 299, 300, 1070, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 1071, - 323, 1072, 325, 326, 327, 328, 1073, 329, 330, 331, - 332, 1074, 794, 334, 1075, 336, 337, 338, 0, 339, - 340, 0, 0, 1076, 342, 343, 0, 0, 344, 345, - 346, 347, 348, 349, 796, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, - 362, 363, 797, 365, 366, 367, 368, 369, 370, 371, - 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, - 380, 381, 382, 1077, 384, 385, 386, 387, 0, 388, - 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, - 399, 400, 0, 401, 402, 403, 404, 405, 406, 1078, - 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, - 426, 427, 428, 429, 0, 430, 431, 432, 1079, 434, - 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, - 444, 445, 446, 447, 448, 799, 0, 0, 450, 451, - 0, 452, 453, 454, 455, 456, 457, 458, 0, 459, - 1080, 1081, 0, 1432, 462, 463, 800, 465, 801, 1082, - 467, 468, 802, 470, 471, 472, 473, 474, 0, 0, - 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, - 483, 484, 485, 486, 487, 1083, 0, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, - 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, - 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, - 518, 519, 1084, 0, 0, 0, 0, 0, 0, 1085, - 1086, 1087, 0, 0, 0, 0, 1088, 0, 1089, 0, - 0, 0, 0, 1090, 1091, 0, 1092, 1093, 1246, 1044, - 819, 1045, 1046, 1047, 1048, 1049, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, - 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, - 0, 0, 1248, 0, 1050, 0, 0, 1249, 130, 131, - 0, 132, 133, 134, 1250, 136, 137, 138, 139, 1051, - 1251, 1052, 1053, 0, 144, 145, 146, 147, 148, 149, - 1054, 789, 150, 151, 152, 153, 1055, 1056, 156, 0, - 157, 158, 159, 160, 790, 0, 1252, 0, 1253, 164, - 165, 166, 167, 168, 1254, 170, 171, 172, 0, 173, - 174, 175, 176, 177, 178, 0, 1255, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 1058, 191, 192, - 1059, 194, 1060, 195, 0, 196, 197, 198, 199, 200, - 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, - 207, 1061, 209, 210, 0, 211, 212, 213, 0, 214, - 215, 216, 0, 217, 218, 219, 220, 1062, 222, 223, - 224, 225, 226, 227, 792, 1063, 229, 0, 230, 231, - 1064, 233, 0, 234, 0, 235, 1257, 0, 1258, 238, - 239, 1259, 1260, 242, 0, 243, 0, 1065, 1066, 246, - 247, 0, 248, 249, 250, 251, 252, 253, 254, 1261, - 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, - 265, 266, 0, 267, 1262, 269, 270, 271, 272, 273, - 274, 1067, 1068, 0, 1069, 0, 278, 1263, 1264, 281, - 1265, 283, 284, 285, 286, 287, 288, 0, 0, 289, - 1266, 291, 1267, 0, 293, 294, 295, 296, 297, 298, - 299, 300, 1268, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 1071, 1269, 1072, 325, 326, 327, 328, - 1073, 329, 330, 1270, 332, 1074, 794, 334, 1075, 336, - 337, 338, 0, 339, 340, 0, 0, 1076, 342, 343, - 0, 0, 344, 345, 346, 1271, 348, 1272, 796, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, - 0, 0, 0, 0, 362, 363, 797, 1273, 366, 367, - 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, - 377, 0, 378, 379, 380, 381, 382, 1077, 384, 385, - 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 397, 398, 399, 400, 0, 401, 402, 1274, - 404, 405, 406, 1078, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 417, 418, 419, 420, 0, 1275, 421, - 422, 423, 424, 425, 426, 427, 428, 429, 0, 1276, - 431, 432, 1079, 434, 0, 435, 436, 437, 438, 439, - 440, 441, 442, 443, 444, 445, 446, 1277, 448, 799, - 0, 0, 450, 451, 0, 452, 1278, 454, 455, 456, - 457, 458, 0, 459, 1080, 1081, 0, 0, 462, 463, - 800, 465, 801, 1082, 467, 468, 1279, 470, 471, 472, - 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, - 480, 481, 0, 482, 483, 484, 485, 486, 487, 1083, - 2286, 489, 1281, 491, 492, 493, 494, 495, 496, 497, - 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, - 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, - 514, 515, 516, 517, 518, 519, 1084, 0, 0, 0, - 0, 0, 0, 1085, 1086, 1087, 0, 0, 0, 0, - 1088, 0, 1089, 0, 0, 0, 0, 1090, 1091, 0, - 1092, 1093, 1246, 1044, 819, 1045, 1046, 1047, 1048, 1049, + 0, 0, 0, 0, 0, 0, 0, 0, 0, -2061, + 0, 0, 1643, 0, 0, 0, 1648, 1649, 1650, 1651, + 1652, 1653, 0, 0, 0, 0, 0, 0, 0, 0, + 1656, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1656, 0, 0, + 0, 0, 0, 0, 0, 0, 1656, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, - 126, 127, 128, 0, 0, 0, 1248, 0, 1050, 0, - 0, 1249, 130, 131, 0, 132, 133, 134, 1250, 136, - 137, 138, 139, 1051, 1251, 1052, 1053, 0, 144, 145, - 146, 147, 148, 149, 1054, 789, 150, 151, 152, 153, - 1055, 1056, 156, 0, 157, 158, 159, 160, 790, 0, - 1252, 0, 1253, 164, 165, 166, 167, 168, 1254, 170, - 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, - 1255, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 189, 1058, 191, 192, 1059, 194, 1060, 195, 0, 196, - 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, - 205, 0, 0, 206, 207, 1061, 209, 210, 0, 211, - 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, - 220, 1062, 222, 223, 224, 225, 226, 227, 792, 1063, - 229, 0, 230, 231, 1064, 233, 0, 234, 0, 235, - 1257, 0, 1258, 238, 239, 1259, 1260, 242, 0, 243, - 0, 1065, 1066, 246, 247, 0, 248, 249, 250, 251, - 252, 253, 254, 1261, 256, 257, 258, 259, 0, 260, - 261, 262, 263, 264, 265, 266, 0, 267, 1262, 269, - 270, 271, 272, 273, 274, 1067, 1068, 0, 1069, 0, - 278, 1263, 1264, 281, 1265, 283, 284, 285, 286, 287, - 288, 0, 0, 289, 1266, 291, 1267, 0, 293, 294, - 295, 296, 297, 298, 299, 300, 1268, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 1071, 1269, 1072, - 325, 326, 327, 328, 1073, 329, 330, 1270, 332, 1074, - 794, 334, 1075, 336, 337, 338, 0, 339, 340, 0, - 0, 1076, 342, 343, 0, 0, 344, 345, 346, 1271, - 348, 1272, 796, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, - 797, 1273, 366, 367, 368, 369, 370, 371, 0, 372, - 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, - 382, 1077, 384, 385, 386, 387, 0, 388, 389, 390, - 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, - 0, 401, 402, 1274, 404, 405, 406, 1078, 408, 409, - 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, - 420, 0, 1275, 421, 422, 423, 424, 425, 426, 427, - 428, 429, 0, 1276, 431, 432, 1079, 434, 0, 435, - 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, - 446, 1277, 448, 799, 0, 0, 450, 451, 0, 452, - 1278, 454, 455, 456, 457, 458, 0, 459, 1080, 1081, - 0, 0, 462, 463, 800, 465, 801, 1082, 467, 468, - 1279, 470, 471, 472, 473, 474, 0, 0, 475, 476, - 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, - 485, 486, 487, 1083, 0, 489, 1281, 491, 492, 493, - 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, - 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, - 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, - 1084, 0, 0, 0, 0, 0, 0, 1085, 1086, 1087, - 0, 0, 0, 0, 1088, 0, 1089, 2340, 0, 0, - 0, 1090, 1091, 0, 1092, 1093, 117, 1044, 819, 1045, - 1046, 1047, 1048, 1049, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, -1116, 126, 127, 128, 0, 0, 0, - 0, -1116, 1050, 0, 0, 129, 130, 131, 0, 132, - 133, 134, 135, 136, 137, 138, 139, 1051, 141, 1052, - 1053, 0, 144, 145, 146, 147, 148, 149, 1054, 789, - 150, 151, 152, 153, 1055, 1056, 156, 0, 157, 158, - 159, 160, 790, 0, 791, 0, 1057, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 1058, 191, 192, 1059, 194, - 1060, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 1061, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 1062, 222, 223, 224, 225, - 226, 227, 792, 1063, 229, 0, 230, 231, 1064, 233, - 0, 234, 0, 235, 236, 0, 237, 238, 239, 240, - 241, 242, 0, 243, 0, 1065, 1066, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 1067, - 1068, 0, 1069, 0, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 290, 291, - 292, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 1070, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 1071, 323, 1072, 325, 326, 327, 328, 1073, 329, - 330, 331, 332, 1074, 794, 334, 1075, 336, 337, 338, - 0, 339, 340, 0, 0, 1076, 342, 343, 0, 0, - 344, 345, 346, 347, 348, 349, 796, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 797, 365, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 1077, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 403, 404, 405, - 406, 1078, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 430, 431, 432, - 1079, 434, -1116, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 447, 448, 799, 0, 0, - 450, 451, 0, 452, 453, 454, 455, 456, 457, 458, - 0, 459, 1080, 1081, 0, 0, 462, 463, 800, 465, - 801, 1082, 467, 468, 802, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 1083, 0, 489, - 490, 491, 492, 493, 494, 495, 496, 497, 0, 0, - 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 1084, 0, 0, 0, 0, 0, - 0, 1085, 1086, 1087, 0, 0, 0, 0, 1088, 0, - 1089, 0, 0, 0, 0, 1090, 1091, 0, 1092, 1093, - 1246, 1044, 819, 1045, 1046, 1047, 1048, 1049, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, - 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, - 128, 0, 0, 0, 1248, 0, 1050, 0, 0, 1249, - 130, 131, 0, 132, 133, 134, 1250, 136, 137, 138, - 139, 1051, 1251, 1052, 1053, 0, 144, 145, 146, 147, - 148, 149, 1054, 789, 150, 151, 152, 153, 1055, 1056, - 156, 0, 157, 158, 159, 160, 790, 0, 1252, 0, - 1253, 164, 165, 166, 167, 168, 1254, 170, 171, 172, - 0, 173, 174, 175, 176, 177, 178, 0, 1255, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 1058, - 191, 192, 1059, 194, 1060, 195, 0, 196, 197, 198, - 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, - 0, 206, 207, 1061, 209, 210, 0, 211, 212, 213, - 0, 214, 215, 216, 0, 217, 218, 219, 220, 1062, - 222, 223, 224, 225, 226, 227, 792, 1063, 229, 0, - 230, 231, 1064, 233, 0, 234, 0, 235, 1257, 0, - 1258, 238, 239, 1259, 1260, 242, 0, 243, 0, 1065, - 1066, 246, 247, 0, 248, 249, 250, 251, 252, 253, - 254, 1261, 256, 257, 258, 259, 0, 260, 261, 262, - 263, 264, 265, 266, 0, 267, 1262, 269, 270, 271, - 272, 273, 274, 1067, 1068, 0, 1069, 0, 278, 1263, - 1264, 281, 1265, 283, 284, 285, 286, 287, 288, 0, - 0, 289, 1266, 291, 1267, 0, 293, 294, 295, 296, - 297, 298, 299, 300, 1268, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 1071, 1269, 1072, 325, 326, - 327, 328, 1073, 329, 330, 1270, 332, 1074, 794, 334, - 1075, 336, 337, 338, 0, 339, 340, 0, 0, 1076, - 342, 343, 0, 0, 344, 345, 346, 1271, 348, 1272, - 796, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, 361, 0, 0, 0, 0, 362, 363, 797, 1273, - 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, - 375, 376, 377, 0, 378, 379, 380, 381, 382, 1077, - 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, - 402, 1274, 404, 405, 406, 1078, 408, 409, 410, 411, - 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, - 1275, 421, 422, 423, 424, 425, 426, 427, 428, 429, - 0, 1276, 431, 432, 1079, 434, 0, 435, 436, 437, - 438, 439, 440, 441, 442, 443, 444, 445, 446, 1277, - 448, 799, 0, 0, 450, 451, 0, 452, 1278, 454, - 455, 456, 457, 458, 0, 459, 1080, 1081, 0, 0, - 462, 463, 800, 465, 801, 1082, 467, 468, 1279, 470, - 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, - 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, - 487, 1083, 0, 489, 1281, 491, 492, 493, 494, 495, - 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, - 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, - 512, 513, 514, 515, 516, 517, 518, 519, 1084, 0, - 0, 0, 0, 0, 0, 1085, 1086, 1087, 0, 0, - 0, 0, 1088, 0, 1089, 3080, 0, 0, 0, 1090, - 1091, 0, 1092, 1093, 1246, 1044, 819, 1045, 1046, 1047, - 1048, 1049, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, - 125, 0, 126, 127, 128, 0, 0, 0, 1248, 0, - 1050, 0, 0, 1249, 130, 131, 0, 132, 133, 134, - 1250, 136, 137, 138, 139, 1051, 1251, 1052, 1053, 0, - 144, 145, 146, 147, 148, 149, 1054, 789, 150, 151, - 152, 153, 1055, 1056, 156, 0, 157, 158, 159, 160, - 790, 0, 1252, 0, 1253, 164, 165, 166, 167, 168, - 1254, 170, 171, 172, 0, 173, 174, 175, 176, 177, - 178, 0, 1255, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 1058, 191, 192, 1059, 194, 1060, 195, - 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, - 203, 204, 205, 0, 0, 206, 207, 1061, 209, 210, - 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, - 218, 219, 220, 1062, 222, 223, 224, 225, 226, 227, - 792, 1063, 229, 0, 230, 231, 1064, 233, 0, 234, - 0, 235, 1257, 0, 1258, 238, 239, 1259, 1260, 242, - 0, 243, 0, 1065, 1066, 246, 247, 0, 248, 249, - 250, 251, 252, 253, 254, 1261, 256, 257, 258, 259, - 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, - 1262, 269, 270, 271, 272, 273, 274, 1067, 1068, 0, - 1069, 0, 278, 1263, 1264, 281, 1265, 283, 284, 285, - 286, 287, 288, 0, 0, 289, 1266, 291, 1267, 0, - 293, 294, 295, 296, 297, 298, 299, 300, 1268, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 1071, - 1269, 1072, 325, 326, 327, 328, 1073, 329, 330, 1270, - 332, 1074, 794, 334, 1075, 336, 337, 338, 0, 339, - 340, 0, 0, 1076, 342, 343, 0, 0, 344, 345, - 346, 1271, 348, 1272, 796, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, - 362, 363, 797, 1273, 366, 367, 368, 369, 370, 371, - 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, - 380, 381, 382, 1077, 384, 385, 386, 387, 0, 388, - 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, - 399, 400, 0, 401, 402, 1274, 404, 405, 406, 1078, - 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 0, 1275, 421, 422, 423, 424, 425, - 426, 427, 428, 429, 0, 1276, 431, 432, 1079, 434, - 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, - 444, 445, 446, 1277, 448, 799, 0, 0, 450, 451, - 0, 452, 1278, 454, 455, 456, 457, 458, 0, 459, - 1080, 1081, 0, 0, 462, 463, 800, 465, 801, 1082, - 467, 468, 1279, 470, 471, 472, 473, 474, 0, 0, - 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, - 483, 484, 485, 486, 487, 1083, 0, 489, 1281, 491, - 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, - 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, - 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, - 518, 519, 1084, 0, 0, 0, 0, 0, 0, 1085, - 1086, 1087, 0, 0, 0, 0, 1088, 0, 1089, 0, - 0, 0, 0, 1090, 1091, 0, 1092, 1093, 117, 1044, - 819, 1045, 1046, 1047, 1048, 1049, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 2184, 0, 0, 0, 0, + 0, 1656, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1656, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1644, + 0, 0, 1645, 1646, 1647, 0, 1648, 1649, 1650, 1651, + 1652, 1653, 0, 117, 1046, 819, 1047, 1048, 1049, 1050, + 1051, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1656, 0, 118, 119, 120, 121, 122, 123, 124, 125, + 0, 126, 127, 128, 0, 0, 0, 0, 0, 1052, + 0, 0, 129, 130, 131, 0, 132, 133, 134, 135, + 136, 137, 138, 139, 1053, 141, 1054, 1055, 0, 144, + 145, 146, 147, 148, 149, 1056, 789, 150, 151, 152, + 153, 1057, 1058, 156, 1656, 157, 158, 159, 160, 790, + 0, 791, 0, 1059, 164, 165, 166, 167, 168, 169, + 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, + 0, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 1060, 191, 192, 1061, 194, 1062, 195, 0, + 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, + 204, 205, 0, 0, 206, 207, 1063, 209, 210, 0, + 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, + 219, 220, 1064, 222, 223, 224, 225, 226, 227, 792, + 1065, 229, 0, 230, 231, 1066, 233, 0, 234, 0, + 235, 236, 0, 237, 238, 239, 240, 241, 242, 0, + 243, 0, 1067, 1068, 246, 247, 0, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 0, + 260, 261, 262, 263, 264, 265, 266, 0, 267, 268, + 269, 270, 271, 272, 273, 274, 1069, 1070, 0, 1071, + 0, 278, 279, 280, 281, 282, 283, 284, 285, 286, + 287, 288, 0, 0, 289, 290, 291, 292, 0, 293, + 294, 295, 296, 297, 298, 299, 300, 1072, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 1073, 323, + 1074, 325, 326, 327, 328, 1075, 329, 330, 331, 332, + 1076, 794, 334, 1077, 336, 337, 338, 0, 339, 340, + 0, 0, 1078, 342, 343, 0, 0, 344, 345, 346, + 347, 348, 349, 796, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, + 363, 797, 365, 366, 367, 368, 369, 370, 371, 0, + 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, + 381, 382, 1079, 384, 385, 386, 387, 0, 388, 389, + 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, + 400, 0, 401, 402, 403, 404, 405, 406, 1080, 408, + 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, + 419, 420, 0, 0, 421, 422, 423, 424, 425, 426, + 427, 428, 429, 0, 430, 431, 432, 1081, 434, 0, + 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, + 445, 446, 447, 448, 799, 0, 0, 450, 451, 0, + 452, 453, 454, 455, 456, 457, 458, 0, 459, 1082, + 1083, 0, 0, 462, 463, 800, 465, 801, 1084, 467, + 468, 802, 470, 471, 472, 473, 474, 0, 0, 475, + 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, + 484, 485, 486, 487, 1085, 0, 489, 490, 491, 492, + 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, + 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, + 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, + 519, 1086, 0, 0, 0, 0, 0, 0, 1087, 1088, + 1089, 0, 0, 0, 0, 1090, 0, 1091, 0, 0, + 0, 0, 1092, 1093, 0, 1094, 1095, 2647, 117, 1046, + 819, 1047, 1048, 1049, 1050, 1051, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, - 121, 122, 123, 124, 125, 1695, 126, 127, 128, 0, - 0, 0, 0, 0, 1050, 0, 0, 129, 130, 131, - 0, 132, 133, 134, 135, 136, 137, 138, 139, 1051, - 141, 1052, 1053, 0, 144, 145, 146, 147, 148, 149, - 1054, 789, 150, 151, 152, 153, 1055, 1056, 156, 0, - 157, 158, 159, 160, 790, 0, 791, 0, 1057, 164, + 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, + 0, 0, 0, 0, 1052, 0, 0, 129, 130, 131, + 0, 132, 133, 134, 135, 136, 137, 138, 139, 1053, + 141, 1054, 1055, 0, 144, 145, 146, 147, 148, 149, + 1056, 789, 150, 151, 152, 153, 1057, 1058, 156, 0, + 157, 158, 159, 160, 790, 0, 791, 0, 1059, 164, 165, 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 1058, 191, 192, - 1059, 194, 1060, 195, 0, 196, 197, 198, 199, 200, + 183, 184, 185, 186, 187, 188, 189, 1060, 191, 192, + 1061, 194, 1062, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, - 207, 1061, 209, 210, 0, 211, 212, 213, 0, 214, - 215, 216, 0, 217, 218, 219, 220, 1062, 222, 223, - 224, 225, 226, 227, 792, 1063, 229, 0, 230, 231, - 1064, 233, 0, 234, 0, 235, 236, 0, 237, 238, - 239, 240, 241, 242, 0, 243, 0, 1065, 1066, 246, + 207, 1063, 209, 210, 0, 211, 212, 213, 0, 214, + 215, 216, 0, 217, 218, 219, 220, 1064, 222, 223, + 224, 225, 226, 227, 792, 1065, 229, 0, 230, 231, + 1066, 233, 0, 234, 0, 235, 236, 0, 237, 238, + 239, 240, 241, 242, 0, 243, 0, 1067, 1068, 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, 270, 271, 272, 273, - 274, 1067, 1068, 0, 1069, 0, 278, 279, 280, 281, + 274, 1069, 1070, 0, 1071, 0, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 0, 0, 289, 290, 291, 292, 0, 293, 294, 295, 296, 297, 298, - 299, 300, 1070, 302, 303, 304, 305, 306, 307, 308, + 299, 300, 1072, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 1071, 323, 1072, 325, 326, 327, 328, - 1073, 329, 330, 331, 332, 1074, 794, 334, 1075, 336, - 337, 338, 0, 339, 340, 0, 0, 1076, 342, 343, + 319, 320, 321, 1073, 323, 1074, 325, 326, 327, 328, + 1075, 329, 330, 331, 332, 1076, 794, 334, 1077, 336, + 337, 338, 0, 339, 340, 0, 0, 1078, 342, 343, 0, 0, 344, 345, 346, 347, 348, 349, 796, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, 797, 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, - 377, 0, 378, 379, 380, 381, 382, 1077, 384, 385, + 377, 0, 378, 379, 380, 381, 382, 1079, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, 403, - 404, 405, 406, 1078, 408, 409, 410, 411, 412, 413, + 404, 405, 406, 1080, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, 429, 0, 430, - 431, 432, 1079, 434, 0, 435, 436, 437, 438, 439, + 431, 432, 1081, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 799, 0, 0, 450, 451, 0, 452, 453, 454, 455, 456, - 457, 458, 0, 459, 1080, 1081, 0, 0, 462, 463, - 800, 465, 801, 1082, 467, 468, 802, 470, 471, 472, + 457, 458, 0, 459, 1082, 1083, 0, 0, 462, 463, + 800, 465, 801, 1084, 467, 468, 802, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, - 480, 481, 0, 482, 483, 484, 485, 486, 487, 1083, + 480, 481, 0, 482, 483, 484, 485, 486, 487, 1085, 0, 489, 490, 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, - 514, 515, 516, 517, 518, 519, 1084, 0, 0, 0, - 0, 0, 0, 1085, 1086, 1087, 0, 0, 0, 0, - 1088, 0, 1089, 0, 0, 0, 0, 1090, 1091, 0, - 1092, 1093, 117, 1710, 819, 1045, 1046, 1047, 1711, 1049, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 118, 119, 120, 121, 122, 123, 124, 125, 1712, - 126, 127, 128, 0, 0, 0, 0, 0, 1050, 0, - 0, 129, 130, 131, 0, 132, 133, 134, 135, 136, - 137, 138, 139, 1051, 141, 1052, 1053, 0, 144, 145, - 146, 147, 148, 149, 1054, 789, 150, 151, 152, 153, - 1055, 1056, 156, 0, 157, 158, 159, 160, 790, 0, - 791, 0, 1057, 164, 165, 166, 167, 168, 169, 170, - 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, - 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 189, 1058, 191, 192, 1059, 194, 1060, 195, 0, 196, - 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, - 205, 0, 0, 206, 207, 1061, 209, 210, 0, 211, - 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, - 220, 1062, 222, 223, 224, 225, 226, 227, 792, 1063, - 229, 0, 230, 231, 1064, 233, 0, 234, 0, 235, - 236, 0, 237, 238, 239, 240, 241, 242, 0, 243, - 0, 1065, 1066, 246, 247, 0, 248, 249, 250, 251, - 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, - 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, - 270, 271, 272, 273, 274, 1067, 1068, 0, 1069, 0, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 0, 0, 289, 290, 291, 292, 0, 293, 294, - 295, 296, 297, 298, 299, 300, 1070, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 1071, 323, 1072, - 325, 326, 327, 328, 1073, 329, 330, 331, 332, 1074, - 794, 334, 1075, 336, 337, 338, 0, 339, 340, 0, - 0, 1076, 342, 343, 0, 0, 344, 345, 346, 347, - 348, 349, 796, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, - 797, 365, 366, 367, 368, 369, 370, 371, 0, 372, - 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, - 382, 1077, 384, 385, 386, 387, 0, 388, 389, 390, - 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, - 0, 401, 402, 403, 404, 405, 406, 1078, 408, 409, - 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, - 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, - 428, 429, 0, 430, 431, 432, 1079, 434, 0, 435, - 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, - 446, 447, 448, 799, 0, 0, 450, 451, 0, 452, - 453, 454, 455, 456, 457, 458, 0, 459, 1080, 1081, - 0, 0, 462, 463, 800, 465, 801, 1082, 467, 468, - 802, 470, 471, 472, 473, 474, 0, 0, 475, 476, - 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, - 485, 486, 487, 1083, 0, 489, 490, 491, 492, 493, - 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, - 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, - 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, - 1084, 0, 0, 0, 0, 0, 0, 1085, 1086, 1087, - 0, 0, 0, 0, 1088, 0, 1089, 0, 0, 0, - 0, 1090, 1091, 0, 1092, 1093, 117, 1044, 819, 1045, - 1046, 1047, 1048, 1049, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 0, 0, 1050, 0, 0, 129, 130, 131, 0, 132, - 133, 134, 135, 136, 137, 138, 139, 1051, 141, 1052, - 1053, 0, 144, 145, 146, 147, 148, 149, 1054, 789, - 150, 151, 152, 153, 1055, 1056, 156, 0, 157, 158, - 159, 160, 790, 0, 791, 0, 1057, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 1058, 191, 192, 1059, 194, - 1060, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 1061, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 1062, 222, 223, 224, 225, - 226, 227, 792, 1063, 229, 0, 230, 231, 1064, 233, - 0, 234, 0, 235, 236, 1430, 237, 238, 239, 240, - 241, 242, 0, 243, 0, 1065, 1066, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 1067, - 1068, 0, 1069, 0, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 290, 291, - 292, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 1070, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 1071, 323, 1072, 325, 326, 327, 328, 1073, 329, - 330, 331, 332, 1074, 794, 334, 1075, 336, 337, 338, - 0, 339, 340, 0, 0, 1076, 342, 343, 0, 0, - 344, 345, 346, 347, 348, 349, 796, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 797, 365, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 1077, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 403, 404, 405, - 406, 1078, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 430, 431, 432, - 1079, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 447, 448, 799, 0, 0, - 450, 451, 0, 452, 453, 454, 455, 456, 457, 458, - 0, 459, 1080, 1081, 0, 0, 462, 463, 800, 465, - 801, 1082, 467, 468, 802, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 1083, 0, 489, - 490, 491, 492, 493, 494, 495, 496, 497, 0, 0, - 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 1084, 0, 0, 0, 0, 0, - 0, 1085, 1086, 1087, 0, 0, 0, 0, 1088, 0, - 1089, 0, 0, 0, 0, 1090, 1091, 0, 1092, 1093, - 117, 1044, 819, 1045, 1046, 1047, 1048, 1049, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, - 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, - 128, 0, 0, 0, 0, 0, 1050, 0, 0, 129, - 130, 131, 0, 132, 133, 134, 135, 136, 137, 138, - 139, 1051, 141, 1052, 1053, 0, 144, 145, 146, 147, - 148, 149, 1054, 789, 150, 151, 152, 153, 1055, 1056, - 156, 0, 157, 158, 159, 160, 790, 0, 791, 0, - 1057, 164, 165, 166, 167, 168, 169, 170, 171, 172, - 0, 173, 174, 175, 176, 177, 178, 0, 179, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 1058, - 191, 192, 1059, 194, 1060, 195, 0, 196, 197, 198, - 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, - 0, 206, 207, 1061, 209, 210, 0, 211, 212, 213, - 0, 214, 215, 216, 0, 217, 218, 219, 220, 1062, - 222, 223, 224, 225, 226, 227, 792, 1063, 229, 0, - 230, 231, 1064, 233, 0, 234, 0, 235, 236, 0, - 237, 238, 239, 240, 241, 242, 0, 243, 0, 1065, - 1066, 246, 247, 0, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 0, 260, 261, 262, - 263, 264, 265, 266, 0, 267, 268, 269, 270, 271, - 272, 273, 274, 1067, 1068, 0, 1069, 0, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 0, - 0, 289, 290, 291, 292, 0, 293, 294, 295, 296, - 297, 298, 299, 300, 1070, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 1071, 323, 1072, 325, 326, - 327, 328, 1073, 329, 330, 331, 332, 1074, 794, 334, - 1075, 336, 337, 338, 0, 339, 340, 0, 0, 1076, - 342, 343, 0, 0, 344, 345, 346, 347, 348, 349, - 796, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, 361, 0, 0, 0, 0, 362, 363, 797, 365, - 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, - 375, 376, 377, 0, 378, 379, 380, 381, 382, 1077, - 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, - 402, 403, 404, 405, 406, 1078, 408, 409, 410, 411, - 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, - 0, 421, 422, 423, 424, 425, 426, 427, 428, 429, - 0, 430, 431, 432, 1079, 434, 0, 435, 436, 437, - 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, - 448, 799, 0, 0, 450, 451, 0, 452, 453, 454, - 455, 456, 457, 458, 0, 459, 1080, 1081, 0, 0, - 462, 463, 800, 465, 801, 1082, 467, 468, 802, 470, - 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, - 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, - 487, 1083, 0, 489, 490, 491, 492, 493, 494, 495, - 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, - 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, - 512, 513, 514, 515, 516, 517, 518, 519, 1084, 0, - 0, 0, 0, 0, 0, 1085, 1086, 1087, 0, 0, - 0, 0, 1088, 0, 1089, 2056, 0, 0, 0, 1090, - 1091, 0, 1092, 1093, 117, 1044, 819, 1045, 1046, 1047, - 1048, 1049, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, - 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, - 1050, 0, 0, 129, 130, 131, 0, 132, 133, 134, - 135, 136, 137, 138, 139, 1051, 141, 1052, 1053, 0, - 144, 145, 146, 147, 148, 149, 1054, 789, 150, 151, - 152, 153, 1055, 1056, 156, 0, 157, 158, 159, 160, - 790, 0, 791, 0, 1057, 164, 165, 166, 167, 168, - 169, 170, 171, 172, 0, 173, 174, 175, 176, 177, - 178, 0, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 1058, 191, 192, 1059, 194, 1060, 195, - 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, - 203, 204, 205, 0, 0, 206, 207, 1061, 209, 210, - 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, - 218, 219, 220, 1062, 222, 223, 224, 225, 226, 227, - 792, 1063, 229, 0, 230, 231, 1064, 233, 0, 234, - 0, 235, 236, 0, 237, 238, 239, 240, 241, 242, - 0, 243, 0, 1065, 1066, 246, 247, 0, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, - 268, 269, 270, 271, 272, 273, 274, 1067, 1068, 0, - 1069, 0, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 0, 0, 289, 290, 291, 292, 0, - 293, 294, 295, 296, 297, 298, 299, 300, 1070, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 1071, - 323, 1072, 325, 326, 327, 328, 1073, 329, 330, 331, - 332, 1074, 794, 334, 1075, 336, 337, 338, 0, 339, - 340, 0, 0, 1076, 342, 343, 0, 0, 344, 345, - 346, 347, 348, 349, 796, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, - 362, 363, 797, 365, 366, 367, 368, 369, 370, 371, - 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, - 380, 381, 382, 1077, 384, 385, 386, 387, 0, 388, - 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, - 399, 400, 0, 401, 402, 403, 404, 405, 406, 1078, - 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, - 426, 427, 428, 429, 0, 430, 431, 432, 1079, 434, - 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, - 444, 445, 446, 447, 448, 799, 0, 0, 450, 451, - 2688, 452, 453, 454, 455, 456, 457, 458, 0, 459, - 1080, 1081, 0, 0, 462, 463, 800, 465, 801, 1082, - 467, 468, 802, 470, 471, 472, 473, 474, 0, 0, - 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, - 483, 484, 485, 486, 487, 1083, 0, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, - 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, - 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, - 518, 519, 1084, 0, 0, 0, 0, 0, 0, 1085, - 1086, 1087, 0, 0, 0, 0, 1088, 0, 1089, 0, - 0, 0, 0, 1090, 1091, 0, 1092, 1093, 117, 1044, - 819, 1045, 1046, 1047, 1048, 1049, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, - 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, - 0, 0, 0, 0, 1050, 0, 0, 129, 130, 131, - 0, 132, 133, 134, 135, 136, 137, 138, 139, 1051, - 141, 1052, 1053, 0, 144, 145, 146, 147, 148, 149, - 1054, 789, 150, 151, 152, 153, 1055, 1056, 156, 0, - 157, 158, 159, 160, 790, 0, 791, 0, 1057, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 0, 173, - 174, 175, 176, 177, 178, 0, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 1058, 191, 192, - 1059, 194, 1060, 195, 0, 196, 197, 198, 199, 200, - 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, - 207, 1061, 209, 210, 0, 211, 212, 213, 0, 214, - 215, 216, 0, 217, 218, 219, 220, 1062, 222, 223, - 224, 225, 226, 227, 792, 1063, 229, 0, 230, 231, - 1064, 233, 0, 234, 0, 235, 236, 0, 237, 238, - 239, 240, 241, 242, 0, 243, 0, 1065, 1066, 246, - 247, 0, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, - 265, 266, 0, 267, 268, 269, 270, 271, 272, 273, - 274, 1067, 1068, 0, 1069, 0, 278, 279, 280, 281, - 282, 283, 284, 285, 286, 287, 288, 0, 0, 289, - 290, 291, 292, 0, 293, 294, 295, 296, 297, 298, - 299, 300, 1070, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 1071, 323, 1072, 325, 326, 327, 328, - 1073, 329, 330, 331, 332, 1074, 794, 334, 1075, 336, - 337, 338, 0, 339, 340, 0, 0, 1076, 342, 343, - 0, 0, 344, 345, 346, 347, 348, 349, 796, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, - 0, 0, 0, 0, 362, 363, 797, 365, 366, 367, - 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, - 377, 0, 378, 379, 380, 381, 382, 1077, 384, 385, - 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 397, 398, 399, 400, 0, 401, 402, 403, - 404, 405, 406, 1078, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, - 422, 423, 424, 425, 426, 427, 428, 429, 0, 430, - 431, 432, 1079, 434, 0, 435, 436, 437, 438, 439, - 440, 441, 442, 443, 444, 445, 446, 447, 448, 799, - 0, 0, 450, 451, 0, 452, 453, 454, 455, 456, - 457, 458, 0, 459, 1080, 1081, 0, 0, 462, 463, - 800, 465, 801, 1082, 467, 468, 802, 470, 471, 472, - 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, - 480, 481, 0, 482, 483, 484, 485, 486, 487, 1083, - 0, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 0, 2809, 498, 0, 0, 499, 500, 501, 502, 503, - 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, - 514, 515, 516, 517, 518, 519, 1084, 0, 0, 0, - 0, 0, 0, 1085, 1086, 1087, 0, 0, 0, 0, - 1088, 0, 1089, 0, 0, 0, 0, 1090, 1091, 0, - 1092, 1093, 117, 1044, 819, 1045, 1046, 1047, 1048, 1049, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 118, 119, 120, 121, 122, 123, 124, 125, 3024, - 126, 127, 128, 0, 0, 0, 0, 0, 1050, 0, - 0, 129, 130, 131, 0, 132, 133, 134, 135, 136, - 137, 138, 139, 1051, 141, 1052, 1053, 0, 144, 145, - 146, 147, 148, 149, 1054, 789, 150, 151, 152, 153, - 1055, 1056, 156, 0, 157, 158, 159, 160, 790, 0, - 791, 0, 1057, 164, 165, 166, 167, 168, 169, 170, - 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, - 179, 180, 3025, 182, 183, 184, 185, 186, 187, 188, - 189, 1058, 191, 192, 1059, 194, 1060, 195, 0, 196, - 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, - 205, 0, 0, 206, 207, 1061, 209, 210, 0, 211, - 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, - 220, 1062, 222, 223, 224, 225, 226, 227, 792, 1063, - 229, 0, 230, 231, 1064, 233, 0, 234, 0, 235, - 236, 0, 237, 238, 239, 240, 241, 242, 0, 243, - 0, 3026, 1066, 246, 247, 0, 248, 249, 250, 251, - 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, - 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, - 270, 271, 272, 273, 274, 1067, 1068, 0, 1069, 0, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 0, 0, 289, 290, 291, 292, 0, 293, 294, - 295, 296, 297, 298, 299, 300, 1070, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 1071, 323, 1072, - 325, 326, 327, 328, 1073, 329, 330, 331, 332, 1074, - 794, 334, 1075, 336, 337, 338, 0, 339, 340, 0, - 0, 1076, 342, 343, 0, 0, 344, 345, 346, 347, - 348, 349, 796, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, - 797, 365, 366, 367, 368, 369, 370, 371, 0, 372, - 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, - 382, 1077, 384, 385, 386, 387, 0, 388, 389, 390, - 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, - 0, 401, 402, 403, 404, 405, 3027, 1078, 408, 409, - 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, - 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, - 428, 429, 0, 430, 431, 432, 1079, 434, 0, 435, - 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, - 446, 447, 448, 799, 0, 0, 450, 451, 0, 452, - 453, 454, 455, 456, 457, 458, 0, 459, 1080, 1081, - 0, 0, 462, 463, 800, 465, 801, 1082, 467, 468, - 802, 470, 471, 472, 473, 474, 0, 0, 475, 476, - 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, - 485, 486, 487, 1083, 0, 489, 490, 491, 492, 493, - 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, - 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, - 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, - 1084, 0, 0, 0, 0, 0, 0, 1085, 1086, 1087, - 0, 0, 0, 0, 1088, 0, 3028, 0, 0, 0, - 0, 1090, 1091, 0, 1092, 1093, 117, 1044, 819, 1045, - 1046, 1047, 1048, 1049, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 0, 0, 1050, 0, 0, 129, 130, 131, 0, 132, - 133, 134, 135, 136, 137, 138, 139, 1051, 141, 1052, - 1053, 0, 144, 145, 146, 147, 148, 149, 1054, 789, - 150, 151, 152, 153, 1055, 1056, 156, 0, 157, 158, - 159, 160, 790, 0, 791, 0, 1057, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 1058, 191, 192, 1059, 194, - 1060, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 1061, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 1062, 222, 223, 224, 225, - 226, 227, 792, 1063, 229, 0, 230, 231, 1064, 233, - 0, 234, 0, 235, 236, 0, 237, 238, 239, 240, - 241, 242, 0, 243, 0, 1065, 1066, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 1067, - 1068, 0, 1069, 0, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 290, 291, - 292, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 1070, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 1071, 323, 1072, 325, 326, 327, 328, 1073, 329, - 330, 331, 332, 1074, 794, 334, 1075, 336, 337, 338, - 0, 339, 340, 0, 0, 1076, 342, 343, 0, 0, - 344, 345, 346, 347, 348, 349, 796, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 797, 365, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 1077, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 403, 404, 405, - 406, 1078, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 430, 431, 432, - 1079, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 447, 448, 799, 0, 0, - 450, 451, 3175, 452, 453, 454, 455, 456, 457, 458, - 0, 459, 1080, 1081, 0, 0, 462, 463, 800, 465, - 801, 1082, 467, 468, 802, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 1083, 0, 489, - 490, 491, 492, 493, 494, 495, 496, 497, 0, 0, - 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 1084, 0, 0, 0, 0, 0, - 0, 1085, 1086, 1087, 0, 0, 0, 0, 1088, 0, - 1089, 0, 0, 0, 0, 1090, 1091, 0, 1092, 1093, - 117, 1044, 819, 1045, 1046, 1047, 1048, 1049, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, - 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, - 128, 0, 0, 0, 0, 0, 1050, 0, 0, 129, - 130, 131, 0, 132, 133, 134, 135, 136, 137, 138, - 139, 1051, 141, 1052, 1053, 0, 144, 145, 146, 147, - 148, 149, 1054, 789, 150, 151, 152, 153, 1055, 1056, - 156, 0, 157, 158, 159, 160, 790, 0, 791, 0, - 1057, 164, 165, 166, 167, 168, 169, 170, 171, 172, - 0, 173, 174, 175, 176, 177, 178, 0, 179, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 1058, - 191, 192, 1059, 194, 1060, 195, 0, 196, 197, 198, - 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, - 0, 206, 207, 1061, 209, 210, 0, 211, 212, 213, - 0, 214, 215, 216, 0, 217, 218, 219, 220, 1062, - 222, 223, 224, 225, 226, 227, 792, 1063, 229, 0, - 230, 231, 1064, 233, 0, 234, 0, 235, 236, 0, - 237, 238, 239, 240, 241, 242, 0, 243, 0, 1065, - 1066, 246, 247, 0, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 0, 260, 261, 262, - 263, 264, 265, 266, 0, 267, 268, 269, 270, 271, - 272, 273, 274, 1067, 1068, 0, 1069, 0, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 0, - 0, 289, 290, 291, 292, 0, 293, 294, 295, 296, - 297, 298, 299, 300, 1070, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 1071, 323, 1072, 325, 326, - 327, 328, 1073, 329, 330, 331, 332, 1074, 794, 334, - 1075, 336, 337, 338, 0, 339, 340, 0, 0, 1076, - 342, 343, 0, 0, 344, 345, 346, 347, 348, 349, - 796, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, 361, 0, 0, 0, 0, 362, 363, 797, 365, - 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, - 375, 376, 377, 0, 378, 379, 380, 381, 382, 1077, - 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, - 402, 403, 404, 405, 406, 1078, 408, 409, 410, 411, - 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, - 0, 421, 422, 423, 424, 425, 426, 427, 428, 429, - 0, 430, 431, 432, 1079, 434, 0, 435, 436, 437, - 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, - 448, 799, 0, 0, 450, 451, 3313, 452, 453, 454, - 455, 456, 457, 458, 0, 459, 1080, 1081, 0, 0, - 462, 463, 800, 465, 801, 1082, 467, 468, 802, 470, - 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, - 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, - 487, 1083, 0, 489, 490, 491, 492, 493, 494, 495, - 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, - 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, - 512, 513, 514, 515, 516, 517, 518, 519, 1084, 0, - 0, 0, 0, 0, 0, 1085, 1086, 1087, 0, 0, - 0, 0, 1088, 0, 1089, 0, 0, 0, 0, 1090, - 1091, 0, 1092, 1093, 117, 1044, 819, 1045, 1046, 1047, - 1048, 1049, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, - 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, - 1050, 0, 0, 129, 130, 131, 0, 132, 133, 134, - 135, 136, 137, 138, 139, 1051, 141, 1052, 1053, 0, - 144, 145, 146, 147, 148, 149, 1054, 789, 150, 151, - 152, 153, 1055, 1056, 156, 0, 157, 158, 159, 160, - 790, 0, 791, 0, 1057, 164, 165, 166, 167, 168, - 169, 170, 171, 172, 0, 173, 174, 175, 176, 177, - 178, 0, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 1058, 191, 192, 1059, 194, 1060, 195, - 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, - 203, 204, 205, 0, 0, 206, 207, 1061, 209, 210, - 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, - 218, 219, 220, 1062, 222, 223, 224, 225, 226, 227, - 792, 1063, 229, 0, 230, 231, 1064, 233, 0, 234, - 0, 235, 236, 0, 237, 238, 239, 240, 241, 242, - 0, 243, 0, 1065, 1066, 246, 247, 0, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, - 268, 269, 270, 271, 272, 273, 274, 1067, 1068, 0, - 1069, 0, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 0, 0, 289, 290, 291, 292, 0, - 293, 294, 295, 296, 297, 298, 299, 300, 1070, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 1071, - 323, 1072, 325, 326, 327, 328, 1073, 329, 330, 331, - 332, 1074, 794, 334, 1075, 336, 337, 338, 0, 339, - 340, 0, 0, 1076, 342, 343, 0, 0, 344, 345, - 346, 347, 348, 349, 796, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, - 362, 363, 797, 365, 366, 367, 368, 369, 370, 371, - 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, - 380, 381, 382, 1077, 384, 385, 386, 387, 0, 388, - 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, - 399, 400, 0, 401, 402, 403, 404, 405, 406, 1078, - 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, - 426, 427, 428, 429, 0, 430, 431, 432, 1079, 434, - 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, - 444, 445, 446, 447, 448, 799, 0, 0, 450, 451, - 0, 452, 453, 454, 455, 456, 457, 458, 0, 459, - 1080, 1081, 0, 0, 462, 463, 800, 465, 801, 1082, - 467, 468, 802, 470, 471, 472, 473, 474, 0, 0, - 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, - 483, 484, 485, 486, 487, 1083, 0, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, - 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, - 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, - 518, 519, 1084, 0, 0, 0, 0, 0, 0, 1085, - 1086, 1087, 0, 0, 0, 0, 1088, 0, 1089, 0, - 0, 0, 0, 1090, 1091, 0, 1092, 1093, 117, 1044, - 819, 1045, 1046, 1047, 1048, 1049, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, - 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, - 0, 0, 0, 0, 1050, 0, 0, 129, 130, 131, - 0, 132, 133, 134, 135, 136, 137, 138, 139, 1051, - 141, 1052, 1053, 0, 144, 145, 146, 147, 148, 149, - 1054, 789, 150, 151, 152, 153, 1055, 1056, 156, 0, - 157, 158, 159, 160, 790, 0, 791, 0, 1057, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 0, 173, - 174, 175, 176, 177, 178, 0, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 1058, 191, 192, - 1059, 194, 1060, 195, 0, 196, 197, 198, 199, 200, - 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, - 207, 1061, 209, 210, 0, 211, 212, 213, 0, 214, - 215, 216, 0, 217, 218, 219, 220, 1062, 222, 223, - 224, 225, 226, 227, 792, 1063, 229, 0, 230, 231, - 1064, 233, 0, 234, 0, 235, 236, 0, 237, 238, - 239, 240, 241, 242, 0, 243, 0, 1065, 1066, 246, - 247, 0, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, - 265, 266, 0, 267, 268, 269, 270, 271, 272, 273, - 274, 1067, 1068, 0, 1069, 0, 278, 279, 280, 281, - 282, 283, 284, 285, 286, 287, 288, 0, 0, 289, - 290, 291, 292, 0, 293, 294, 295, 296, 297, 298, - 299, 300, 1070, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 1071, 323, 1072, 325, 326, 327, 328, - 1073, 329, 330, 331, 332, 1074, 794, 334, 1075, 336, - 337, 338, 0, 339, 340, 0, 0, 1076, 342, 343, - 0, 0, 344, 345, 346, 347, 348, 349, 796, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, - 0, 0, 0, 0, 362, 363, 797, 365, 366, 367, - 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, - 377, 0, 378, 379, 380, 381, 382, 1077, 384, 385, - 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 397, 398, 399, 400, 0, 401, 402, 403, - 404, 405, 406, 1078, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, - 422, 423, 424, 425, 426, 427, 428, 429, 0, 430, - 431, 432, 1079, 434, 0, 435, 436, 437, 438, 439, - 440, 441, 442, 443, 444, 445, 446, 447, 448, 799, - 0, 0, 450, 451, 0, 452, 453, 454, 455, 456, - 457, 458, 0, 459, 1080, 1081, 0, 0, 462, 463, - 800, 465, 801, 1082, 467, 468, 802, 470, 471, 472, - 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, - 480, 481, 0, 482, 483, 484, 485, 486, 487, 1083, - 0, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, - 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, - 514, 515, 516, 517, 518, 519, 1084, 0, 0, 0, - 0, 0, 0, 1715, 1716, 1087, 0, 0, 0, 0, - 1088, 0, 1089, 0, 0, 0, 0, 1090, 1091, 0, - 1092, 1093, 117, 2197, 819, 1045, 1046, 1047, 1048, 1049, + 514, 515, 516, 517, 518, 519, 1086, 0, 0, 0, + 0, 0, 0, 1087, 1088, 1089, 0, 0, 0, 0, + 1090, 0, 1091, 0, 0, 0, 0, 1092, 1093, 0, + 1094, 1095, 3251, 117, 1046, 819, 1047, 1048, 1049, 1050, + 1051, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, + 0, 126, 127, 128, 0, 0, 0, 0, 0, 1052, + 0, 0, 129, 130, 131, 0, 132, 133, 134, 135, + 136, 137, 138, 139, 1053, 141, 1054, 1055, 0, 144, + 145, 146, 147, 148, 149, 1056, 789, 150, 151, 152, + 153, 1057, 1058, 156, 0, 157, 158, 159, 160, 790, + 0, 791, 0, 1059, 164, 165, 166, 167, 168, 169, + 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, + 0, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 1060, 191, 192, 1061, 194, 1062, 195, 0, + 196, 197, 198, 199, 200, 201, 14, 15, 202, 203, + 204, 205, 0, 0, 206, 207, 1063, 209, 210, 0, + 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, + 219, 220, 1064, 222, 223, 224, 225, 226, 227, 792, + 1065, 229, 0, 230, 231, 1066, 233, 0, 234, 0, + 235, 236, 23, 237, 238, 239, 240, 241, 242, 0, + 243, 0, 1067, 1068, 246, 247, 0, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 0, + 260, 261, 262, 263, 264, 265, 266, 0, 267, 268, + 269, 270, 271, 272, 273, 274, 1069, 1070, 0, 1071, + 0, 278, 279, 280, 281, 282, 283, 284, 285, 286, + 287, 288, 0, 0, 289, 290, 291, 292, 0, 293, + 294, 295, 296, 297, 298, 299, 300, 1072, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 1073, 323, + 1074, 325, 326, 327, 328, 1075, 329, 330, 331, 332, + 1076, 794, 334, 1077, 336, 337, 338, 0, 339, 340, + 0, 0, 1078, 342, 343, 0, 0, 344, 345, 346, + 347, 348, 349, 796, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 360, 361, 26, 27, 28, 0, 362, + 363, 797, 365, 366, 367, 368, 369, 370, 371, 0, + 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, + 381, 382, 1079, 384, 385, 386, 387, 0, 388, 389, + 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, + 400, 0, 401, 402, 403, 404, 405, 406, 1080, 408, + 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, + 419, 420, 33, 0, 421, 422, 423, 424, 425, 426, + 427, 428, 429, 35, 430, 431, 432, 1081, 434, 0, + 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, + 445, 446, 447, 448, 799, 37, 0, 450, 451, 38, + 452, 453, 454, 455, 456, 457, 458, 0, 459, 1082, + 1083, 0, 0, 462, 463, 800, 465, 801, 1084, 467, + 468, 802, 470, 471, 472, 473, 474, 0, 0, 475, + 476, 477, 40, 478, 479, 480, 481, 0, 482, 483, + 484, 485, 486, 803, 1085, 0, 489, 490, 491, 492, + 493, 494, 495, 496, 497, 0, 0, 498, 0, 44, + 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, + 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, + 519, 1086, 0, 45, 0, 0, 0, 0, 1087, 1088, + 1089, 0, 0, 0, 0, 1090, 0, 1091, 3226, 0, + 0, 0, 1092, 1093, 0, 1094, 1095, 117, 1046, 819, + 1047, 1048, 1049, 1050, 1051, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, + 0, 0, 0, 1052, 0, 0, 129, 130, 131, 0, + 132, 133, 134, 135, 136, 137, 138, 139, 1053, 141, + 1054, 1055, 0, 144, 145, 146, 147, 148, 149, 1056, + 789, 150, 151, 152, 153, 1057, 1058, 156, 0, 157, + 158, 159, 160, 790, 0, 791, 0, 1059, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 1060, 191, 192, 1061, + 194, 1062, 195, 0, 196, 197, 198, 199, 200, 201, + 14, 15, 202, 203, 204, 205, 0, 0, 206, 207, + 1063, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 1064, 222, 223, 224, + 225, 226, 227, 792, 1065, 229, 0, 230, 231, 1066, + 233, 0, 234, 0, 235, 236, 23, 237, 238, 239, + 240, 241, 242, 0, 243, 0, 1067, 1068, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, + 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 1069, 1070, 0, 1071, 0, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 290, + 291, 292, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 1072, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 1073, 323, 1074, 325, 326, 327, 328, 1075, + 329, 330, 331, 332, 1076, 794, 334, 1077, 336, 337, + 338, 0, 339, 340, 0, 0, 1078, 342, 343, 0, + 0, 344, 345, 346, 347, 348, 349, 796, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 26, + 27, 28, 0, 362, 363, 797, 365, 366, 367, 368, + 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, + 0, 378, 379, 380, 381, 382, 1079, 384, 385, 386, + 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 0, 401, 402, 403, 404, + 405, 406, 1080, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 33, 0, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 35, 430, 431, + 432, 1081, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 447, 448, 799, 37, + 0, 450, 451, 38, 452, 453, 454, 455, 456, 457, + 458, 0, 459, 1082, 1083, 0, 0, 462, 463, 800, + 465, 801, 1084, 467, 468, 802, 470, 471, 472, 473, + 474, 0, 0, 475, 476, 477, 40, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 803, 1085, 0, + 489, 490, 491, 492, 493, 494, 495, 496, 497, 0, + 0, 498, 0, 44, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 1086, 0, 45, 0, 0, + 0, 0, 1087, 1088, 1089, 0, 0, 0, 0, 1090, + 0, 1091, 0, 0, 0, 0, 1092, 1093, 0, 1094, + 1095, 117, 1046, 819, 1047, 1048, 1049, 1050, 1051, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, - 126, 127, 128, 0, 0, 0, 0, 0, 1050, 0, - 0, 129, 130, 131, 0, 132, 133, 134, 135, 136, - 137, 138, 139, 1051, 141, 1052, 1053, 0, 144, 145, - 146, 147, 148, 149, 1054, 789, 150, 151, 152, 153, - 1055, 1056, 156, 0, 157, 158, 159, 160, 790, 0, - 791, 0, 1057, 164, 165, 166, 167, 168, 169, 170, - 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, - 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 189, 1058, 191, 192, 1059, 194, 1060, 195, 0, 196, - 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, - 205, 0, 0, 206, 207, 1061, 209, 210, 0, 211, - 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, - 220, 1062, 222, 223, 224, 225, 226, 227, 792, 1063, - 229, 0, 230, 231, 1064, 233, 0, 234, 0, 235, - 236, 0, 237, 238, 239, 240, 241, 242, 0, 243, - 0, 1065, 1066, 246, 247, 0, 248, 249, 250, 251, - 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, - 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, - 270, 271, 272, 273, 274, 1067, 1068, 0, 1069, 0, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 0, 0, 289, 290, 291, 292, 0, 293, 294, - 295, 296, 297, 298, 299, 300, 1070, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 1071, 323, 1072, - 325, 326, 327, 328, 1073, 329, 330, 331, 332, 1074, - 794, 334, 1075, 336, 337, 338, 0, 339, 340, 0, - 0, 1076, 342, 343, 0, 0, 344, 345, 346, 347, - 348, 349, 796, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, - 797, 365, 366, 367, 368, 369, 370, 371, 0, 372, - 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, - 382, 1077, 384, 385, 386, 387, 0, 388, 389, 390, - 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, - 0, 401, 402, 403, 404, 405, 406, 1078, 408, 409, - 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, - 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, - 428, 429, 0, 430, 431, 432, 1079, 434, 0, 435, - 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, - 446, 447, 448, 799, 0, 0, 450, 451, 0, 452, - 453, 454, 455, 456, 457, 458, 0, 459, 1080, 1081, - 0, 0, 462, 463, 800, 465, 801, 1082, 467, 468, - 802, 470, 471, 472, 473, 474, 0, 0, 475, 476, - 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, - 485, 486, 487, 1083, 0, 489, 490, 491, 492, 493, - 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, - 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, - 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, - 1084, 0, 0, 0, 0, 0, 0, 1085, 1086, 1087, - 0, 0, 0, 0, 1088, 0, 1089, 0, 0, 0, - 0, 1090, 1091, 0, 1092, 1093, 117, 1044, 819, 1045, - 1046, 1047, 1048, 1049, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 0, 0, 1050, 0, 0, 129, 130, 131, 0, 132, - 133, 134, 135, 136, 137, 138, 139, 1051, 141, 1052, - 1053, 0, 144, 145, 146, 147, 148, 149, 1054, 789, - 150, 151, 152, 153, 1055, 1056, 156, 0, 157, 158, - 159, 160, 790, 0, 791, 0, 1057, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 1058, 191, 192, 1059, 194, - 1060, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 1061, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 1062, 222, 223, 224, 225, - 226, 227, 792, 1063, 229, 0, 230, 231, 1064, 233, - 0, 234, 0, 235, 236, 0, 237, 238, 239, 240, - 241, 242, 0, 243, 0, 1065, 1066, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 1067, - 1068, 0, 1069, 0, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 290, 291, - 292, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 1070, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 1071, 323, 1072, 325, 326, 327, 328, 1073, 329, - 330, 331, 332, 1074, 794, 334, 1075, 336, 337, 338, - 0, 339, 340, 0, 0, 1076, 342, 343, 0, 0, - 344, 345, 346, 347, 348, 349, 796, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 797, 365, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 1077, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 403, 404, 405, - 406, 1078, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 430, 431, 432, - 1079, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 447, 448, 799, 0, 0, - 450, 451, 0, 452, 453, 454, 455, 456, 457, 458, - 0, 459, 1080, 1081, 0, 0, 462, 463, 800, 465, - 801, 1082, 467, 468, 802, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 1083, 0, 489, - 490, 491, 492, 493, 494, 495, 496, 497, 0, 0, - 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 1084, 0, 0, 0, 0, 0, - 0, 1085, 2280, 1087, 0, 0, 0, 0, 1088, 0, - 1089, 0, 0, 0, 0, 1090, 1091, 0, 1092, 1093, - 117, 1044, 819, 1045, 1046, 1047, 1048, 1049, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, - 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, - 128, 0, 0, 0, 0, 0, 1050, 0, 0, 129, - 130, 131, 0, 132, 133, 134, 135, 136, 137, 138, - 139, 1051, 141, 1052, 1053, 0, 144, 145, 146, 147, - 148, 149, 1054, 789, 150, 151, 152, 153, 1055, 1056, - 156, 0, 157, 158, 159, 160, 790, 0, 791, 0, - 1057, 164, 165, 166, 167, 168, 169, 170, 171, 172, - 0, 173, 174, 175, 176, 177, 178, 0, 179, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 1058, - 191, 192, 1059, 194, 1060, 195, 0, 196, 197, 198, - 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, - 0, 206, 207, 1061, 209, 210, 0, 211, 212, 213, - 0, 214, 215, 216, 0, 217, 218, 219, 220, 1062, - 222, 223, 224, 225, 226, 227, 792, 1063, 229, 0, - 230, 231, 1064, 233, 0, 234, 0, 235, 236, 0, - 237, 238, 239, 240, 241, 242, 0, 243, 0, 1065, - 1066, 246, 247, 0, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 0, 260, 261, 262, - 263, 264, 265, 266, 0, 267, 268, 269, 270, 271, - 272, 273, 274, 1067, 1068, 0, 1069, 0, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 0, - 0, 289, 290, 291, 292, 0, 293, 294, 295, 296, - 297, 298, 299, 300, 1070, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 1071, 323, 1072, 325, 326, - 327, 328, 1073, 329, 330, 331, 332, 1074, 794, 334, - 1075, 336, 337, 338, 0, 339, 340, 0, 0, 1076, - 342, 343, 0, 0, 344, 345, 346, 347, 348, 349, - 796, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, 361, 0, 0, 0, 0, 362, 363, 797, 365, - 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, - 375, 376, 377, 0, 378, 379, 380, 381, 382, 1077, - 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, - 402, 403, 404, 405, 406, 1078, 408, 409, 410, 411, - 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, - 0, 421, 422, 423, 424, 425, 426, 427, 428, 429, - 0, 430, 431, 432, 1079, 434, 0, 435, 436, 437, - 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, - 448, 799, 0, 0, 450, 451, 0, 452, 453, 454, - 455, 456, 457, 458, 0, 459, 1080, 1081, 0, 0, - 462, 463, 800, 465, 801, 1082, 467, 468, 802, 470, - 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, - 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, - 487, 1083, 0, 489, 490, 491, 492, 493, 494, 495, - 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, - 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, - 512, 513, 514, 515, 516, 517, 518, 519, 1084, 0, - 0, 0, 0, 0, 0, 1085, 1086, 1087, 0, 0, - 0, 0, 1088, 0, 2493, 0, 0, 0, 0, 1090, - 1091, 0, 1092, 1093, 117, 1044, 819, 1045, 1046, 1047, - 1048, 1049, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, - 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, - 1050, 0, 0, 129, 130, 131, 0, 132, 133, 134, - 135, 136, 137, 138, 139, 1051, 141, 1052, 1053, 0, - 144, 145, 146, 147, 148, 149, 1054, 789, 150, 151, - 152, 153, 1055, 1056, 156, 0, 157, 158, 159, 160, - 790, 0, 791, 0, 1057, 164, 165, 166, 167, 168, - 169, 170, 171, 172, 0, 173, 174, 175, 176, 177, - 178, 0, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 1058, 191, 192, 1059, 194, 1060, 195, - 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, - 203, 204, 205, 0, 0, 206, 207, 1061, 209, 210, - 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, - 218, 219, 220, 1062, 222, 223, 224, 225, 226, 227, - 792, 1063, 229, 0, 230, 231, 1064, 233, 0, 234, - 0, 235, 236, 0, 237, 238, 239, 240, 241, 242, - 0, 243, 0, 1065, 1066, 246, 247, 0, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, - 268, 269, 270, 271, 272, 273, 274, 1067, 1068, 0, - 1069, 0, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 0, 0, 289, 290, 291, 292, 0, - 293, 294, 295, 296, 297, 298, 299, 300, 1070, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 1071, - 323, 1072, 325, 326, 327, 328, 1073, 329, 330, 331, - 332, 1074, 794, 334, 1075, 336, 337, 338, 0, 339, - 340, 0, 0, 1076, 342, 343, 0, 0, 344, 345, - 346, 347, 348, 349, 796, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, - 362, 363, 797, 365, 366, 367, 368, 369, 370, 371, - 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, - 380, 381, 382, 1077, 384, 385, 386, 387, 0, 388, - 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, - 399, 400, 0, 401, 402, 403, 404, 405, 406, 1078, - 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, - 426, 427, 428, 429, 0, 430, 431, 432, 1079, 434, - 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, - 444, 445, 446, 447, 448, 799, 0, 0, 450, 451, - 0, 452, 453, 454, 455, 456, 457, 458, 0, 459, - 1080, 1081, 0, 0, 462, 463, 800, 465, 801, 1082, - 467, 468, 802, 470, 471, 472, 473, 474, 0, 0, - 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, - 483, 484, 485, 486, 487, 1083, 0, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, - 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, - 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, - 518, 519, 1084, 0, 0, 0, 0, 0, 0, 1085, - 3078, 1087, 0, 0, 0, 0, 1088, 0, 1089, 0, - 0, 0, 0, 1090, 1091, 0, 1092, 1093, 117, 1044, - 819, 1045, 1046, 1047, 1048, 1049, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, - 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, - 0, 0, 0, 0, 1050, 0, 0, 129, 130, 131, - 0, 132, 133, 134, 135, 136, 137, 138, 139, 1051, - 141, 1052, 1053, 0, 144, 145, 146, 147, 148, 149, - 1054, 789, 150, 151, 152, 153, 1055, 1056, 156, 0, - 157, 158, 159, 160, 790, 0, 791, 0, 1057, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 0, 173, - 174, 175, 176, 177, 178, 0, 179, 180, 3025, 182, - 183, 184, 185, 186, 187, 188, 189, 1058, 191, 192, - 1059, 194, 1060, 195, 0, 196, 197, 198, 199, 200, - 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, - 207, 1061, 209, 210, 0, 211, 212, 213, 0, 214, - 215, 216, 0, 217, 218, 219, 220, 1062, 222, 223, - 224, 225, 226, 227, 792, 1063, 229, 0, 230, 231, - 1064, 233, 0, 234, 0, 235, 236, 0, 237, 238, - 239, 240, 241, 242, 0, 243, 0, 3026, 1066, 246, - 247, 0, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, - 265, 266, 0, 267, 268, 269, 270, 271, 272, 273, - 274, 1067, 1068, 0, 1069, 0, 278, 279, 280, 281, - 282, 283, 284, 285, 286, 287, 288, 0, 0, 289, - 290, 291, 292, 0, 293, 294, 295, 296, 297, 298, - 299, 300, 1070, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 1071, 323, 1072, 325, 326, 327, 328, - 1073, 329, 330, 331, 332, 1074, 794, 334, 1075, 336, - 337, 338, 0, 339, 340, 0, 0, 1076, 342, 343, - 0, 0, 344, 345, 346, 347, 348, 349, 796, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, - 0, 0, 0, 0, 362, 363, 797, 365, 366, 367, - 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, - 377, 0, 378, 379, 380, 381, 382, 1077, 384, 385, - 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 397, 398, 399, 400, 0, 401, 402, 403, - 404, 405, 3027, 1078, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, - 422, 423, 424, 425, 426, 427, 428, 429, 0, 430, - 431, 432, 1079, 434, 0, 435, 436, 437, 438, 439, - 440, 441, 442, 443, 444, 445, 446, 447, 448, 799, - 0, 0, 450, 451, 0, 452, 453, 454, 455, 456, - 457, 458, 0, 459, 1080, 1081, 0, 0, 462, 463, - 800, 465, 801, 1082, 467, 468, 802, 470, 471, 472, - 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, - 480, 481, 0, 482, 483, 484, 485, 486, 487, 1083, - 0, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, - 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, - 514, 515, 516, 517, 518, 519, 1084, 0, 0, 0, - 0, 0, 0, 1085, 1086, 1087, 0, 0, 0, 0, - 1088, 0, 3028, 0, 0, 0, 0, 1090, 1091, 0, - 1092, 1093, 117, 1044, 819, 1045, 1046, 1047, 1048, 1049, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, - 126, 127, 128, 0, 0, 0, 0, 0, 1050, 0, - 0, 129, 130, 131, 0, 132, 133, 134, 135, 136, - 137, 138, 3486, 1051, 141, 1052, 1053, 0, 144, 145, - 146, 147, 148, 149, 1054, 789, 150, 151, 152, 153, - 1055, 1056, 156, 0, 157, 158, 159, 160, 790, 0, - 791, 0, 1057, 164, 165, 166, 167, 168, 169, 170, - 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, - 179, 180, 181, 3487, 183, 184, 185, 186, 187, 188, - 189, 1058, 191, 192, 1059, 194, 1060, 195, 0, 196, - 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, - 205, 0, 0, 206, 207, 1061, 209, 210, 0, 211, - 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, - 220, 1062, 222, 223, 224, 225, 226, 227, 792, 1063, - 229, 0, 230, 231, 1064, 233, 0, 234, 0, 235, - 236, 0, 237, 238, 239, 240, 241, 242, 0, 243, - 0, 1065, 1066, 246, 247, 0, 248, 249, 250, 251, - 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, - 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, - 270, 271, 272, 273, 274, 1067, 1068, 0, 1069, 0, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 0, 0, 289, 290, 291, 292, 0, 293, 294, - 295, 296, 297, 298, 299, 300, 1070, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 1071, 323, 1072, - 325, 326, 327, 328, 1073, 329, 330, 331, 332, 1074, - 794, 334, 1075, 336, 337, 338, 0, 339, 340, 0, - 0, 1076, 342, 343, 0, 0, 344, 345, 346, 347, - 348, 349, 796, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, - 797, 365, 366, 367, 368, 369, 370, 371, 0, 372, - 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, - 382, 1077, 384, 385, 386, 387, 0, 388, 389, 390, - 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, - 0, 401, 402, 403, 404, 405, 406, 1078, 408, 409, - 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, - 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, - 428, 429, 0, 430, 431, 432, 1079, 434, 0, 435, - 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, - 446, 447, 448, 799, 0, 0, 450, 451, 0, 452, - 453, 454, 455, 456, 457, 458, 0, 459, 1080, 1081, - 0, 0, 462, 463, 800, 465, 801, 1082, 467, 468, - 802, 470, 471, 3488, 473, 474, 0, 0, 475, 476, - 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, - 485, 486, 487, 1083, 0, 489, 490, 491, 492, 493, - 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, - 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, - 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, - 1084, 0, 0, 0, 0, 0, 0, 1085, 1086, 1087, - 0, 0, 0, 0, 1088, 0, 1089, 0, 0, 0, - 0, 1090, 1091, 0, 1092, 1093, 117, 1044, 819, 1045, - 1046, 1047, 1048, 1049, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 0, 0, 1050, 0, 0, 129, 130, 131, 0, 132, - 133, 134, 135, 136, 137, 138, 139, 1051, 141, 1052, - 1053, 0, 144, 145, 146, 147, 148, 149, 1054, 789, - 150, 151, 152, 153, 1055, 1056, 156, 0, 157, 158, - 159, 160, 790, 0, 791, 0, 1057, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 179, 180, 181, 3487, 183, 184, - 185, 186, 187, 188, 189, 1058, 191, 192, 1059, 194, - 1060, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 1061, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 1062, 222, 223, 224, 225, - 226, 227, 792, 1063, 229, 0, 230, 231, 1064, 233, - 0, 234, 0, 235, 236, 0, 237, 238, 239, 240, - 241, 242, 0, 243, 0, 1065, 1066, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 1067, - 1068, 0, 1069, 0, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 290, 291, - 292, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 1070, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 1071, 323, 1072, 325, 326, 327, 328, 1073, 329, - 330, 331, 332, 1074, 794, 334, 1075, 336, 337, 338, - 0, 339, 340, 0, 0, 1076, 342, 343, 0, 0, - 344, 345, 346, 347, 348, 349, 796, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 797, 365, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 1077, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 403, 404, 405, - 406, 1078, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 430, 431, 432, - 1079, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 447, 448, 799, 0, 0, - 450, 451, 0, 452, 453, 454, 455, 456, 457, 458, - 0, 459, 1080, 1081, 0, 0, 462, 463, 800, 465, - 801, 1082, 467, 468, 802, 470, 471, 3488, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 1083, 0, 489, - 490, 491, 492, 493, 494, 495, 496, 497, 0, 0, - 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 1084, 0, 0, 0, 0, 0, - 0, 1085, 1086, 1087, 0, 0, 0, 0, 1088, 0, - 1089, 0, 0, 0, 0, 1090, 1091, 0, 1092, 1093, - 117, 1044, 819, 1045, 1046, 1047, 1048, 1049, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, - 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, - 128, 0, 0, 0, 0, 0, 1050, 0, 0, 129, - 130, 131, 0, 132, 133, 134, 135, 136, 137, 138, - 139, 1051, 141, 1052, 1053, 0, 144, 145, 146, 147, - 148, 149, 1054, 789, 150, 151, 152, 153, 1055, 1056, - 156, 0, 157, 158, 159, 160, 790, 0, 791, 0, - 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, - 0, 173, 174, 175, 176, 177, 178, 0, 179, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 1058, - 191, 192, 1059, 194, 0, 195, 0, 196, 197, 198, - 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, - 0, 206, 207, 1061, 209, 210, 0, 211, 212, 213, - 0, 214, 215, 216, 0, 217, 218, 219, 220, 1062, - 222, 223, 224, 225, 226, 227, 792, 1063, 229, 0, - 230, 231, 1064, 233, 0, 234, 0, 235, 236, 0, - 237, 238, 239, 240, 241, 242, 0, 243, 0, 1065, - 1066, 246, 247, 0, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 0, 260, 261, 262, - 263, 264, 265, 266, 0, 267, 268, 269, 270, 271, - 272, 273, 274, 1067, 1068, 0, 1069, 0, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 0, - 0, 289, 290, 291, 292, 0, 293, 294, 295, 296, - 297, 298, 299, 300, 1070, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 1071, 323, 1072, 325, 326, - 327, 328, 0, 329, 330, 331, 332, 1074, 794, 334, - 1075, 336, 337, 338, 0, 339, 340, 0, 0, 1076, - 342, 343, 0, 0, 344, 345, 346, 347, 348, 349, - 796, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, 361, 0, 0, 0, 0, 362, 363, 797, 365, - 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, - 375, 376, 377, 0, 378, 379, 380, 381, 382, 1077, - 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, - 402, 403, 404, 405, 406, 1078, 408, 409, 410, 411, - 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, - 0, 421, 422, 423, 424, 425, 426, 427, 428, 429, - 0, 430, 431, 432, 1079, 434, 0, 435, 436, 437, - 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, - 448, 799, 0, 0, 450, 451, 0, 452, 453, 454, - 455, 456, 457, 458, 0, 459, 1080, 1081, 0, 0, - 462, 463, 800, 465, 801, 1082, 467, 468, 802, 470, - 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, - 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, - 487, 1083, 0, 489, 490, 491, 492, 493, 494, 495, - 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, - 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, - 512, 513, 514, 515, 516, 517, 518, 519, 0, 0, - 0, 0, 0, 0, 0, 1416, 1417, 0, 0, 0, - 0, 0, 1088, 0, 1089, 0, 0, 0, 0, 1090, - 1091, 0, 1092, 1093, 117, 1044, 819, 1045, 1046, 1047, - 1048, 1049, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, - 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, - 1050, 0, 0, 129, 130, 131, 0, 132, 133, 134, - 135, 136, 137, 138, -2058, 1051, 141, 1052, 1053, 0, - 144, 145, 146, 147, 148, 149, 1054, 789, 150, 151, - 152, 153, 1055, 1056, 156, 0, 157, 158, 159, 160, - 790, 0, 791, 0, 1057, 164, 165, 166, 167, 168, - 169, 170, 171, 172, 0, 173, 174, 175, 176, 177, - 178, 0, 179, 180, 181, 3487, 183, 184, 185, 186, - 187, 188, 189, 1058, 191, 192, 1059, 194, 1060, 195, - 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, - 203, 204, 205, 0, 0, 206, 207, 1061, 209, 210, - 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, - 218, 219, 220, 1062, 222, 223, 224, 225, 226, 227, - 792, 1063, 229, 0, 230, 231, 1064, 233, 0, 234, - 0, 235, 236, 0, 237, 238, 239, 240, -2058, 242, - 0, 243, 0, 1065, 1066, 246, 247, 0, 248, 249, - 250, 251, 252, 253, 254, -2058, 256, 257, 258, 259, - 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, - 268, 269, 270, 271, 272, 273, 274, 1067, 1068, 0, - 1069, 0, 278, 0, 0, 281, 282, 283, 284, 285, - 286, 287, 288, 0, 0, 289, 290, 291, -2058, 0, - 293, 294, 295, 296, 297, 298, 299, 300, 1070, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 1071, - 323, 1072, 325, 326, 327, 328, 0, 329, 330, 0, - 332, 1074, 794, 334, 1075, 336, 337, 338, 0, 339, - 340, 0, 0, 1076, 342, 343, 0, 0, 344, 345, - 346, 347, 348, 349, 796, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, - 362, 363, 797, 365, 366, 367, 368, 369, 370, 371, - 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, - 380, 381, 382, 1077, 384, 385, 386, 387, 0, 388, - 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, - 399, 400, 0, 401, 402, 403, 404, 405, 406, 1078, - 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, - 426, 427, 428, 429, 0, -2058, 431, 432, 1079, 434, - 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, - 444, 445, 446, 447, 448, 799, 0, 0, 450, 451, - 0, 452, 453, 454, 455, 456, 457, 458, 0, 459, - 1080, 1081, 0, 0, 462, 463, 800, 465, 801, 1082, - 467, 468, 802, 470, 471, 3488, 473, 474, 0, 0, - 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, - 483, 484, 485, 486, 487, 1083, 0, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, - 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, - 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, - 518, 519, -2058, 0, 0, 0, 0, 0, 0, 1085, - 1086, 1087, 0, 0, 0, 0, 1088, 0, 1089, 0, - 0, 0, 0, 1090, 1091, 0, 1092, 1093, 117, 1044, - 819, 1045, 1046, 0, 1048, 1049, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, - 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, - 0, 0, 0, 0, 1050, 0, 0, 129, 130, 131, - 0, 132, 133, 134, 135, 136, 137, 138, 139, 1051, - 141, 1052, 1053, 0, 144, 145, 146, 147, 148, 149, - 1054, 789, 150, 151, 152, 153, 1055, 1056, 156, 0, - 157, 158, 159, 160, 790, 0, 791, 0, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 0, 173, - 174, 175, 176, 177, 178, 0, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 1058, 191, 192, - 1059, 194, 0, 195, 0, 196, 197, 198, 199, 200, - 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, - 207, 1061, 209, 210, 0, 211, 212, 213, 0, 214, - 215, 216, 0, 217, 218, 219, 220, 1062, 222, 223, - 224, 225, 226, 227, 792, 1063, 229, 0, 230, 231, - 1064, 233, 0, 234, 0, 235, 236, 0, 237, 238, - 239, 240, 241, 242, 0, 243, 0, 1065, 1066, 246, - 247, 0, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, - 265, 266, 0, 267, 268, 269, 270, 271, 272, 273, - 274, 1067, 1068, 0, 1069, 0, 278, 279, 280, 281, - 282, 283, 284, 285, 286, 287, 288, 0, 0, 289, - 290, 291, 292, 0, 293, 294, 295, 296, 297, 298, - 299, 300, 1070, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 1071, 323, 1072, 325, 326, 327, 328, - 0, 329, 330, 331, 332, 1074, 794, 334, 1075, 336, - 337, 338, 0, 339, 340, 0, 0, 341, 342, 343, - 0, 0, 344, 345, 346, 347, 348, 349, 796, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, - 0, 0, 0, 0, 362, 363, 797, 365, 366, 367, - 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, - 377, 0, 378, 379, 380, 381, 382, 1077, 384, 385, - 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 397, 398, 399, 400, 0, 401, 402, 403, - 404, 405, 406, 2183, 2184, 409, 410, 411, 412, 413, - 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, - 422, 423, 424, 425, 426, 427, 428, 429, 0, 430, - 431, 432, 1079, 434, 0, 435, 436, 437, 438, 439, - 440, 441, 442, 443, 444, 445, 446, 447, 448, 799, - 0, 0, 450, 451, 0, 452, 453, 454, 455, 456, - 457, 458, 0, 459, 1080, 1081, 0, 0, 462, 463, - 800, 465, 801, 1082, 467, 468, 802, 470, 471, 472, - 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, - 480, 481, 0, 482, 483, 484, 485, 486, 487, 1083, - 0, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, - 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, - 514, 515, 516, 517, 518, 519, 0, 0, 0, 0, - 0, 0, 0, 2185, 2186, 0, 0, 0, 0, 0, - 1088, 0, 1089, 0, 0, 0, 0, 1090, 1091, 0, - 1092, 1093, 117, 1044, 819, 1045, 1046, 1047, 1048, 1049, + 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, + 127, 128, 0, 0, 0, 0, 0, 1052, 0, 0, + 129, 130, 131, 0, 132, 133, 134, 135, 136, 137, + 138, 139, 1053, 141, 1054, 1055, 0, 144, 145, 146, + 147, 148, 149, 1056, 789, 150, 151, 152, 153, 1057, + 1058, 156, 0, 157, 158, 159, 160, 790, 0, 791, + 0, 1059, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 0, 173, 174, 175, 176, 177, 178, 0, 179, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 1060, 191, 192, 1061, 194, 1062, 195, 0, 196, 197, + 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, + 0, 0, 206, 207, 1063, 209, 210, 0, 211, 212, + 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, + 1064, 222, 223, 224, 225, 226, 227, 792, 1065, 229, + 0, 230, 231, 1066, 233, 0, 234, 0, 235, 236, + 23, 237, 238, 239, 240, 241, 242, 0, 243, 0, + 1067, 1068, 246, 247, 0, 248, 249, 250, 251, 252, + 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, + 262, 263, 264, 265, 266, 0, 267, 268, 269, 270, + 271, 272, 273, 274, 1069, 1070, 0, 1071, 0, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 0, 0, 289, 290, 291, 292, 0, 293, 294, 295, + 296, 297, 298, 299, 300, 1072, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 1073, 323, 1074, 325, + 326, 327, 328, 1075, 329, 330, 331, 332, 1076, 794, + 334, 1077, 336, 337, 338, 0, 339, 340, 0, 0, + 1078, 342, 343, 0, 0, 344, 345, 346, 347, 348, + 349, 796, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 360, 361, 26, 27, 28, 0, 362, 363, 797, + 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, + 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, + 1079, 384, 385, 386, 387, 0, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, + 401, 402, 403, 404, 405, 406, 1080, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, + 33, 0, 421, 422, 423, 424, 425, 426, 427, 428, + 429, 0, 430, 431, 432, 1081, 434, 0, 435, 436, + 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, + 447, 448, 799, 0, 0, 450, 451, 38, 452, 453, + 454, 455, 456, 457, 458, 0, 459, 1082, 1083, 0, + 0, 462, 463, 800, 465, 801, 1084, 467, 468, 802, + 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, + 40, 478, 479, 480, 481, 0, 482, 483, 484, 485, + 486, 803, 1085, 0, 489, 490, 491, 492, 493, 494, + 495, 496, 497, 0, 0, 498, 0, 44, 499, 500, + 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, + 511, 512, 513, 514, 515, 516, 517, 518, 519, 1086, + 0, 45, 0, 0, 0, 0, 1087, 1088, 1089, 0, + 0, 0, 0, 1090, 0, 1091, 0, 0, 0, 0, + 1092, 1093, 0, 1094, 1095, 1251, 1046, 819, 1047, 1048, + 1049, 1050, 1051, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, + 124, 125, 1252, 126, 127, 128, 0, 0, 0, 1253, + 0, 1052, 0, 0, 1254, 130, 131, 0, 132, 133, + 134, 1255, 136, 137, 138, 139, 1053, 1256, 1054, 1055, + 0, 144, 145, 146, 147, 148, 149, 1056, 789, 150, + 151, 152, 153, 1057, 1058, 156, 0, 157, 158, 159, + 160, 790, 0, 1257, 0, 1258, 164, 165, 166, 167, + 168, 1259, 170, 171, 172, 0, 173, 174, 175, 176, + 177, 178, 0, 1260, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 1060, 191, 192, 1061, 194, 1062, + 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, + 202, 203, 204, 205, 1261, 0, 206, 207, 1063, 209, + 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, + 217, 218, 219, 220, 1064, 222, 223, 224, 225, 226, + 227, 792, 1065, 229, 0, 230, 231, 1066, 233, 0, + 234, 0, 235, 1262, 0, 1263, 238, 239, 1264, 1265, + 242, 0, 243, 0, 1067, 1068, 246, 247, 0, 248, + 249, 250, 251, 252, 253, 254, 1266, 256, 257, 258, + 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, + 267, 1267, 269, 270, 271, 272, 273, 274, 1069, 1070, + 0, 1071, 0, 278, 1268, 1269, 281, 1270, 283, 284, + 285, 286, 287, 288, 0, 0, 289, 1271, 291, 1272, + 0, 293, 294, 295, 296, 297, 298, 299, 300, 1273, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 1073, 1274, 1074, 325, 326, 327, 328, 1075, 329, 330, + 1275, 332, 1076, 794, 334, 1077, 336, 337, 338, 0, + 339, 340, 0, 0, 1078, 342, 343, 0, 0, 344, + 345, 346, 1276, 348, 1277, 796, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, + 0, 362, 363, 797, 1278, 366, 367, 368, 369, 370, + 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, + 379, 380, 381, 382, 1079, 384, 385, 386, 387, 0, + 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, + 398, 399, 400, 0, 401, 402, 1279, 404, 405, 406, + 1080, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 417, 418, 419, 420, 0, 1280, 421, 422, 423, 424, + 425, 426, 427, 428, 429, 0, 1281, 431, 432, 1081, + 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, + 443, 444, 445, 446, 1282, 448, 799, 0, 0, 450, + 451, 0, 452, 1283, 454, 455, 456, 457, 458, 0, + 459, 1082, 1083, 0, 0, 462, 463, 800, 465, 801, + 1084, 467, 468, 1284, 470, 471, 472, 473, 474, 0, + 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, + 482, 483, 484, 485, 486, 487, 1085, 1285, 489, 1286, + 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, + 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, + 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, + 517, 518, 519, 1086, 0, 0, 0, 0, 0, 0, + 1087, 1088, 1089, 0, 0, 0, 0, 1090, 0, 1091, + 1287, 0, 0, 0, 1092, 1093, 0, 1094, 1095, 117, + 1046, 819, 1047, 1048, 0, 1050, 1051, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, + 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, + 0, 0, 0, 0, 0, 1052, 0, 0, 129, 130, + 131, 0, 132, 133, 134, 135, 136, 137, 138, 139, + 1053, 141, 1054, 1055, 0, 144, 145, 146, 147, 148, + 149, 1056, 789, 150, 151, 152, 153, 1057, 1058, 156, + 0, 157, 158, 159, 160, 790, 0, 791, 0, 163, + 164, 165, 166, 167, 168, 169, 170, 171, 172, 0, + 173, 174, 175, 176, 177, 178, 0, 179, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 1060, 191, + 192, 1061, 194, 0, 195, 0, 196, 197, 198, 199, + 200, 201, 14, 15, 202, 203, 204, 205, 0, 0, + 206, 207, 1063, 209, 210, 0, 211, 212, 213, 0, + 214, 215, 216, 0, 217, 218, 219, 220, 1064, 222, + 223, 224, 225, 226, 227, 792, 1065, 229, 0, 230, + 231, 1066, 233, 0, 234, 0, 235, 236, 23, 237, + 238, 239, 240, 241, 242, 0, 243, 0, 1067, 1068, + 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 0, 260, 261, 262, 263, + 264, 265, 266, 0, 267, 268, 269, 270, 271, 272, + 273, 274, 1069, 1070, 0, 1071, 0, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 0, 0, + 289, 290, 291, 292, 0, 293, 294, 295, 296, 297, + 298, 299, 300, 1072, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 1073, 323, 1074, 325, 326, 327, + 328, 0, 329, 330, 331, 332, 1076, 794, 334, 1077, + 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, + 343, 0, 0, 344, 345, 346, 347, 348, 349, 796, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + 361, 26, 27, 28, 0, 362, 363, 797, 365, 366, + 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, + 376, 377, 0, 378, 379, 380, 381, 382, 1079, 384, + 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, + 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, + 403, 404, 405, 406, 1080, 408, 409, 410, 411, 412, + 413, 414, 415, 416, 417, 418, 419, 420, 33, 0, + 421, 422, 423, 424, 425, 426, 427, 428, 429, 35, + 430, 431, 432, 1081, 434, 0, 435, 436, 437, 438, + 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, + 799, 37, 0, 450, 451, 38, 452, 453, 454, 455, + 456, 457, 458, 0, 459, 1082, 1083, 0, 0, 462, + 463, 800, 465, 801, 1084, 467, 468, 802, 470, 471, + 472, 473, 474, 0, 0, 475, 476, 477, 40, 478, + 479, 480, 481, 0, 482, 483, 484, 485, 486, 803, + 1085, 0, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 0, 0, 498, 0, 44, 499, 500, 501, 502, + 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, + 513, 514, 515, 516, 517, 518, 519, 0, 0, 45, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, - 126, 127, 128, 0, 0, 0, 0, 0, 1050, 0, - 0, 129, 130, 131, 0, 132, 133, 134, 135, 136, - 137, 138, 139, 1051, 141, 1052, 1053, 0, 144, 145, - 146, 147, 148, 149, 1054, 789, 150, 151, 152, 153, - 1055, 1056, 156, 0, 157, 158, 159, 160, 790, 0, - 791, 0, 163, 164, 165, 166, 167, 168, 169, 170, - 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, - 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 189, 1058, 191, 192, 1059, 194, 0, 195, 0, 196, - 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, - 205, 0, 0, 206, 207, 1061, 209, 210, 0, 211, - 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, - 220, 1062, 222, 223, 224, 225, 226, 227, 792, 1063, - 229, 0, 230, 231, 1064, 233, 0, 234, 0, 235, - 236, 0, 237, 238, 239, 240, 241, 242, 0, 243, - 0, 1065, 1066, 246, 247, 0, 248, 249, 250, 251, - 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, - 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, - 270, 271, 272, 273, 274, 1067, 1068, 0, 1069, 0, - 278, 0, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 0, 0, 289, 290, 291, 292, 0, 293, 294, - 295, 296, 297, 298, 299, 300, 1070, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 1071, 323, 1072, - 325, 326, 327, 328, 0, 329, 330, 331, 332, 1074, - 794, 334, 1075, 336, 337, 338, 0, 339, 340, 0, - 0, 1076, 342, 343, 0, 0, 344, 345, 346, 347, - 348, 349, 796, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, - 797, 365, 366, 367, 368, 369, 370, 371, 0, 372, - 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, - 382, 1077, 384, 385, 386, 387, 0, 388, 389, 390, - 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, - 0, 401, 402, 403, 404, 405, 406, 1078, 408, 409, - 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, - 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, - 428, 429, 0, 430, 431, 432, 1079, 434, 0, 435, - 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, - 446, 447, 448, 799, 0, 0, 450, 451, 0, 452, - 453, 454, 455, 456, 457, 458, 0, 459, 1080, 1081, - 0, 0, 462, 463, 800, 465, 801, 1082, 467, 468, - 802, 470, 471, 472, 473, 474, 0, 0, 475, 476, - 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, - 485, 486, 487, 1083, 0, 489, 490, 491, 492, 493, - 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, - 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, - 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, - 0, 0, 0, 0, 0, 0, 0, 1416, 1417, 0, - 0, 0, 0, 0, 1088, 0, 1089, 0, 0, 0, - 0, 1090, 1091, 0, 1092, 1093, 117, 1044, 819, 1045, - 1046, 0, 1048, 1049, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 0, 0, 1050, 0, 0, 129, 130, 131, 0, 132, - 133, 134, 135, 136, 137, 138, 139, 1051, 141, 1052, - 1053, 0, 144, 145, 146, 147, 148, 149, 1054, 789, - 150, 151, 152, 153, 1055, 1056, 156, 0, 157, 158, - 159, 160, 790, 0, 791, 0, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 1058, 191, 192, 1059, 194, - 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 1061, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 1062, 222, 223, 224, 225, - 226, 227, 792, 1063, 229, 0, 230, 231, 1064, 233, - 0, 234, 0, 235, 236, 0, 237, 238, 239, 240, - 241, 242, 0, 243, 3045, 1065, 1066, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, -720, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 1067, - 1068, 0, 1069, 0, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 290, 291, - 292, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 1070, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 1071, 323, 1072, 325, 326, 327, 328, 0, 329, - 330, 331, 332, 1074, 794, 334, 1075, 336, 337, 338, - 0, 339, 340, 0, 0, 341, 342, 343, 0, 0, - 344, 345, 346, 347, 348, 349, 796, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 797, 365, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 1077, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 430, 431, 432, - 1079, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 447, 448, 799, 0, 0, - 450, 451, 0, 452, 453, 454, 455, 456, 457, 458, - 0, 459, 1080, 1081, 0, 0, 462, 463, 800, 465, - 801, 1082, 467, 468, 802, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 1083, 0, 489, - 490, 491, 492, 493, 494, 495, 496, 497, 0, 0, - 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1088, 0, - 2738, 0, 0, 0, 0, 1090, 1091, 0, 1092, 1093, - 117, 1044, 819, 1045, 1046, 0, 1048, 1049, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, - 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, - 128, 0, 0, 0, 0, 0, 1050, 0, 0, 129, - 130, 131, 0, 132, 133, 134, 135, 136, 137, 138, - 139, 1051, 141, 1052, 1053, 0, 144, 145, 146, 147, - 148, 149, 1054, 789, 150, 151, 152, 153, 1055, 1056, - 156, 0, 157, 158, 159, 160, 790, 0, 791, 0, - 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, - 0, 173, 174, 175, 176, 177, 178, 0, 179, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 1058, - 191, 192, 1059, 194, 0, 195, 0, 196, 197, 198, - 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, - 0, 206, 207, 1061, 209, 210, 0, 211, 212, 213, - 0, 214, 215, 216, 0, 217, 218, 219, 220, 1062, - 222, 223, 224, 225, 226, 227, 792, 1063, 229, 0, - 230, 231, 1064, 233, 0, 234, 0, 235, 236, 0, - 237, 238, 239, 240, 241, 242, 0, 243, 0, 1065, - 1066, 246, 247, 0, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 0, 260, 261, 262, - 263, 264, 265, 266, 0, 267, 268, 269, 270, 271, - 272, 273, 274, 1067, 1068, 0, 1069, 0, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 0, - 0, 289, 290, 291, 292, 0, 293, 294, 295, 296, - 297, 298, 299, 300, 1070, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 1071, 323, 1072, 325, 326, - 327, 328, 0, 329, 330, 331, 332, 1074, 794, 334, - 1075, 336, 337, 338, 0, 339, 340, 0, 0, 341, - 342, 343, 0, 0, 344, 345, 346, 347, 348, 349, - 796, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, 361, 0, 0, 0, 0, 362, 363, 797, 365, - 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, - 375, 376, 377, 0, 378, 379, 380, 381, 382, 1077, - 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, - 0, 421, 422, 423, 424, 425, 426, 427, 428, 429, - 0, 430, 431, 432, 1079, 434, 0, 435, 436, 437, - 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, - 448, 799, 0, 0, 450, 451, 0, 452, 453, 454, - 455, 456, 457, 458, 0, 459, 1080, 1081, 0, 0, - 462, 463, 800, 465, 801, 1082, 467, 468, 802, 470, - 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, - 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, - 487, 1083, 0, 489, 490, 491, 492, 493, 494, 495, - 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, - 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, - 512, 513, 514, 515, 516, 517, 518, 519, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1088, 0, 2738, 0, 0, 0, 0, 1090, - 1091, 0, 1092, 1093, 117, 1044, 819, 1045, 1046, 0, - 1048, 1049, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, - 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, - 1050, 0, 0, 129, 130, 131, 0, 132, 133, 134, - 135, 136, 137, 138, 139, 1051, 141, 1052, 1053, 0, - 144, 145, 146, 147, 148, 149, 1054, 789, 150, 151, - 152, 153, 1055, 1056, 156, 0, 157, 158, 159, 160, - 790, 0, 791, 0, 163, 164, 165, 166, 167, 168, - 169, 170, 171, 172, 0, 173, 174, 175, 176, 177, - 178, 0, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 1058, 191, 192, 1059, 194, 0, 195, - 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, - 203, 204, 205, 0, 0, 206, 207, 1061, 209, 210, - 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, - 218, 219, 220, 1062, 222, 223, 224, 225, 226, 227, - 792, 1063, 229, 0, 230, 231, 1064, 233, 0, 234, - 0, 235, 236, 0, 237, 238, 239, 240, 241, 242, - 0, 243, 0, 1065, 1066, 246, 247, 0, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, - 268, 269, 270, 271, 272, 273, 274, 1067, 1068, 0, - 1069, 0, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 0, 0, 289, 290, 291, 292, 0, - 293, 294, 295, 296, 297, 298, 299, 300, 1070, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 1071, - 323, 1072, 325, 326, 327, 328, 0, 329, 330, 331, - 332, 1074, 794, 334, 1075, 336, 337, 338, 0, 339, - 340, 0, 0, 341, 342, 343, 0, 0, 344, 345, - 346, 347, 348, 349, 796, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, - 362, 363, 797, 365, 366, 367, 368, 369, 370, 371, - 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, - 380, 381, 382, 1077, 384, 385, 386, 387, 0, 388, - 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, - 399, 400, 0, 401, 402, 403, 404, 405, 406, 1078, - 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, - 426, 427, 428, 429, 0, 430, 431, 432, 1079, 434, - 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, - 444, 445, 446, 447, 448, 799, 0, 0, 450, 451, - 0, 452, 453, 454, 455, 456, 457, 458, 0, 459, - 1080, 1081, 0, 0, 462, 463, 800, 465, 801, 1082, - 467, 468, 802, 470, 471, 472, 473, 474, 0, 0, - 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, - 483, 484, 485, 486, 487, 1083, 0, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, - 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, - 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, - 518, 519, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1088, 0, 1089, 0, - 0, 0, 0, 1090, 1091, 0, 1092, 1093, 117, 1044, - 819, 1045, 1046, 1047, 1048, 1049, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, - 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, - 0, 0, 0, 0, 1050, 0, 0, 129, 130, 131, - 0, 132, 133, 134, 135, 136, 137, 138, 0, 1051, - 141, 1052, 1053, 0, 144, 145, 146, 147, 148, 149, - 1054, 789, 150, 151, 152, 153, 1055, 1056, 156, 0, - 157, 158, 159, 160, 790, 0, 791, 0, 1057, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 0, 173, - 174, 175, 176, 177, 178, 0, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 1058, 191, 192, - 1059, 194, 1060, 195, 0, 196, 197, 198, 199, 200, - 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, - 207, 1061, 209, 210, 0, 211, 212, 213, 0, 214, - 0, 216, 0, 217, 218, 219, 220, 1062, 222, 223, - 224, 225, 226, 227, 792, 1063, 229, 0, 230, 231, - 1064, 233, 0, 234, 0, 235, 236, 0, 237, 238, - 239, 240, 0, 242, 0, 243, 0, 1065, 1066, 246, - 247, 0, 248, 249, 250, 251, 252, 253, 254, 0, - 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, - 265, 266, 0, 267, 268, 269, 270, 271, 272, 273, - 274, 1067, 1068, 0, 1069, 0, 278, 0, 0, 281, - 282, 283, 284, 285, 286, 287, 288, 0, 0, 289, - 290, 291, 0, 0, 293, 294, 295, 296, 297, 298, - 299, 300, 1070, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 1071, 323, 1072, 325, 326, 327, 328, - 0, 329, 330, 0, 332, 1074, 794, 334, 1075, 336, - 337, 338, 0, 339, 340, 0, 0, 1076, 342, 343, - 0, 0, 344, 345, 346, 347, 348, 349, 796, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, - 0, 0, 0, 0, 362, 363, 797, 365, 366, 367, - 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, - 377, 0, 378, 379, 380, 381, 382, 1077, 384, 385, - 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 397, 398, 399, 400, 0, 401, 402, 403, - 404, 405, 406, 1078, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, - 422, 423, 424, 425, 426, 427, 428, 429, 0, 0, - 431, 432, 1079, 434, 0, 435, 436, 437, 438, 439, - 440, 441, 442, 443, 444, 445, 446, 447, 448, 799, - 0, 0, 450, 451, 0, 452, 453, 454, 455, 456, - 457, 458, 0, 459, 1080, 1081, 0, 0, 462, 463, - 800, 465, 801, 1082, 467, 468, 802, 470, 471, 472, - 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, - 480, 481, 0, 482, 483, 484, 485, 486, 487, 1083, - 0, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, - 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, - 514, 515, 516, 517, 518, 519, 0, 0, 0, 0, - 0, 0, 0, 1085, 1086, 1087, 0, 968, 1345, 819, - 1088, 0, 1089, 1048, 0, 0, 0, 1090, 1091, 0, - 1092, 1093, 0, 0, 0, 0, 118, 119, 120, 121, + 0, 1090, 0, 1091, 0, 0, 0, 0, 1092, 1093, + 0, 1094, 1095, 117, 1046, 819, 1047, 1048, 1049, 1050, + 1051, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, + 0, 126, 127, 128, 0, 0, 0, 0, 0, 1052, + 0, 0, 129, 130, 131, 0, 132, 133, 134, 135, + 136, 137, 138, 139, 1053, 141, 1054, 1055, 1434, 144, + 145, 146, 147, 148, 149, 1056, 789, 150, 151, 152, + 153, 1057, 1058, 156, 0, 157, 158, 159, 160, 790, + 0, 791, 0, 1059, 164, 165, 166, 167, 168, 169, + 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, + 0, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 1060, 191, 192, 1061, 194, 1062, 195, 0, + 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, + 204, 205, 0, 0, 206, 207, 1063, 209, 210, 0, + 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, + 219, 220, 1064, 222, 223, 224, 225, 226, 227, 792, + 1065, 229, 0, 230, 231, 1066, 233, 0, 234, 0, + 235, 236, 1435, 237, 238, 239, 240, 241, 242, 0, + 243, 0, 1067, 1068, 246, 247, 0, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 0, + 260, 261, 262, 263, 264, 265, 266, 0, 267, 268, + 269, 270, 271, 272, 273, 274, 1069, 1070, 0, 1071, + 0, 278, 279, 280, 281, 282, 283, 284, 285, 286, + 287, 288, 0, 1436, 289, 290, 291, 292, 0, 293, + 294, 295, 296, 297, 298, 299, 300, 1072, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 1073, 323, + 1074, 325, 326, 327, 328, 1075, 329, 330, 331, 332, + 1076, 794, 334, 1077, 336, 337, 338, 0, 339, 340, + 0, 0, 1078, 342, 343, 0, 0, 344, 345, 346, + 347, 348, 349, 796, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, + 363, 797, 365, 366, 367, 368, 369, 370, 371, 0, + 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, + 381, 382, 1079, 384, 385, 386, 387, 0, 388, 389, + 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, + 400, 0, 401, 402, 403, 404, 405, 406, 1080, 408, + 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, + 419, 420, 0, 0, 421, 422, 423, 424, 425, 426, + 427, 428, 429, 0, 430, 431, 432, 1081, 434, 0, + 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, + 445, 446, 447, 448, 799, 0, 0, 450, 451, 0, + 452, 453, 454, 455, 456, 457, 458, 0, 459, 1082, + 1083, 0, 1437, 462, 463, 800, 465, 801, 1084, 467, + 468, 802, 470, 471, 472, 473, 474, 0, 0, 475, + 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, + 484, 485, 486, 487, 1085, 0, 489, 490, 491, 492, + 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, + 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, + 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, + 519, 1086, 0, 0, 0, 0, 0, 0, 1087, 1088, + 1089, 0, 0, 0, 0, 1090, 0, 1091, 0, 0, + 0, 0, 1092, 1093, 0, 1094, 1095, 1251, 1046, 819, + 1047, 1048, 1049, 1050, 1051, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, - 0, 564, 0, 0, 0, 0, 569, 130, 131, 0, - 132, 133, 134, 571, 136, 137, 138, 572, 573, 574, - 575, 576, 0, 144, 145, 146, 147, 148, 149, 0, - 0, 150, 151, 152, 153, 580, 581, 156, 0, 157, - 158, 159, 160, 583, 0, 585, 0, 587, 164, 165, - 166, 167, 168, 588, 170, 171, 172, 0, 173, 174, - 175, 176, 177, 178, 0, 591, 180, 181, 182, 183, - 184, 185, 186, 187, 188, 189, 593, 191, 192, 594, - 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, + 0, 1253, 0, 1052, 0, 0, 1254, 130, 131, 0, + 132, 133, 134, 1255, 136, 137, 138, 139, 1053, 1256, + 1054, 1055, 0, 144, 145, 146, 147, 148, 149, 1056, + 789, 150, 151, 152, 153, 1057, 1058, 156, 0, 157, + 158, 159, 160, 790, 0, 1257, 0, 1258, 164, 165, + 166, 167, 168, 1259, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 1260, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 1060, 191, 192, 1061, + 194, 1062, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, - 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, - 216, 0, 217, 218, 219, 220, 604, 222, 223, 224, - 225, 226, 227, 605, 1346, 229, 0, 230, 231, 608, - 233, 0, 234, 0, 235, 611, 0, 613, 238, 239, - 614, 615, 242, 0, 243, 0, 618, 619, 246, 247, - 0, 248, 249, 250, 251, 252, 253, 254, 621, 256, + 1063, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 1064, 222, 223, 224, + 225, 226, 227, 792, 1065, 229, 0, 230, 231, 1066, + 233, 0, 234, 0, 235, 1262, 0, 1263, 238, 239, + 1264, 1265, 242, 0, 243, 0, 1067, 1068, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 1266, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, - 266, 0, 267, 624, 625, 270, 271, 272, 273, 274, - 626, 627, 0, 629, 0, 278, 631, 632, 281, 633, - 283, 284, 285, 286, 287, 288, 0, 0, 289, 636, - 291, 637, 0, 293, 294, 295, 296, 297, 298, 299, - 300, 639, 302, 303, 304, 305, 306, 307, 308, 309, + 266, 0, 267, 1267, 269, 270, 271, 272, 273, 274, + 1069, 1070, 0, 1071, 0, 278, 1268, 1269, 281, 1270, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 1271, + 291, 1272, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 1273, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 640, 641, 642, 325, 326, 327, 643, 0, - 329, 330, 645, 332, 0, 647, 334, 648, 336, 337, - 338, 0, 339, 340, 1347, 0, 341, 342, 343, 0, - 0, 344, 345, 654, 655, 348, 656, 657, 351, 352, + 320, 321, 1073, 1274, 1074, 325, 326, 327, 328, 1075, + 329, 330, 1275, 332, 1076, 794, 334, 1077, 336, 337, + 338, 0, 339, 340, 0, 0, 1078, 342, 343, 0, + 0, 344, 345, 346, 1276, 348, 1277, 796, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, - 0, 0, 0, 362, 363, 662, 663, 366, 367, 664, + 0, 0, 0, 362, 363, 797, 1278, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, - 0, 378, 379, 380, 381, 382, 667, 384, 385, 386, + 0, 378, 379, 380, 381, 382, 1079, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, - 396, 397, 398, 399, 400, 0, 401, 402, 670, 404, - 405, 406, 671, 408, 409, 410, 411, 412, 413, 414, - 415, 416, 417, 418, 419, 420, 0, 673, 421, 422, - 423, 424, 425, 426, 674, 428, 429, 0, 676, 431, - 432, 677, 434, 0, 435, 436, 437, 438, 439, 440, - 441, 442, 443, 444, 445, 446, 679, 448, 680, 0, - 0, 450, 451, 0, 452, 684, 454, 455, 456, 457, - 458, 0, 459, 686, 687, 0, 0, 462, 463, 690, - 465, 691, 1348, 467, 468, 693, 470, 471, 472, 473, + 396, 397, 398, 399, 400, 0, 401, 402, 1279, 404, + 405, 406, 1080, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 0, 1280, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 0, 1281, 431, + 432, 1081, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 1282, 448, 799, 0, + 0, 450, 451, 0, 452, 1283, 454, 455, 456, 457, + 458, 0, 459, 1082, 1083, 0, 0, 462, 463, 800, + 465, 801, 1084, 467, 468, 1284, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, - 481, 0, 482, 483, 484, 485, 486, 698, 699, 0, - 489, 701, 491, 492, 493, 494, 495, 496, 497, 0, + 481, 0, 482, 483, 484, 485, 486, 487, 1085, 2295, + 489, 1286, 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, - 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, - 716, 516, 517, 518, 519, 0, 0, 0, 0, 527, - 0, 0, 1349, 1350, 2358, 0, 0, 0, 0, 2359, - 0, 2360, 0, 0, 0, 0, 0, 1091, 118, 119, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 1086, 0, 0, 0, 0, + 0, 0, 1087, 1088, 1089, 0, 0, 0, 0, 1090, + 0, 1091, 0, 0, 0, 0, 1092, 1093, 0, 1094, + 1095, 1251, 1046, 819, 1047, 1048, 1049, 1050, 1051, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, + 127, 128, 0, 0, 0, 1253, 0, 1052, 0, 0, + 1254, 130, 131, 0, 132, 133, 134, 1255, 136, 137, + 138, 139, 1053, 1256, 1054, 1055, 0, 144, 145, 146, + 147, 148, 149, 1056, 789, 150, 151, 152, 153, 1057, + 1058, 156, 0, 157, 158, 159, 160, 790, 0, 1257, + 0, 1258, 164, 165, 166, 167, 168, 1259, 170, 171, + 172, 0, 173, 174, 175, 176, 177, 178, 0, 1260, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 1060, 191, 192, 1061, 194, 1062, 195, 0, 196, 197, + 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, + 0, 0, 206, 207, 1063, 209, 210, 0, 211, 212, + 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, + 1064, 222, 223, 224, 225, 226, 227, 792, 1065, 229, + 0, 230, 231, 1066, 233, 0, 234, 0, 235, 1262, + 0, 1263, 238, 239, 1264, 1265, 242, 0, 243, 0, + 1067, 1068, 246, 247, 0, 248, 249, 250, 251, 252, + 253, 254, 1266, 256, 257, 258, 259, 0, 260, 261, + 262, 263, 264, 265, 266, 0, 267, 1267, 269, 270, + 271, 272, 273, 274, 1069, 1070, 0, 1071, 0, 278, + 1268, 1269, 281, 1270, 283, 284, 285, 286, 287, 288, + 0, 0, 289, 1271, 291, 1272, 0, 293, 294, 295, + 296, 297, 298, 299, 300, 1273, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 1073, 1274, 1074, 325, + 326, 327, 328, 1075, 329, 330, 1275, 332, 1076, 794, + 334, 1077, 336, 337, 338, 0, 339, 340, 0, 0, + 1078, 342, 343, 0, 0, 344, 345, 346, 1276, 348, + 1277, 796, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 360, 361, 0, 0, 0, 0, 362, 363, 797, + 1278, 366, 367, 368, 369, 370, 371, 0, 372, 373, + 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, + 1079, 384, 385, 386, 387, 0, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, + 401, 402, 1279, 404, 405, 406, 1080, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, + 0, 1280, 421, 422, 423, 424, 425, 426, 427, 428, + 429, 0, 1281, 431, 432, 1081, 434, 0, 435, 436, + 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, + 1282, 448, 799, 0, 0, 450, 451, 0, 452, 1283, + 454, 455, 456, 457, 458, 0, 459, 1082, 1083, 0, + 0, 462, 463, 800, 465, 801, 1084, 467, 468, 1284, + 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, + 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, + 486, 487, 1085, 0, 489, 1286, 491, 492, 493, 494, + 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, + 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, + 511, 512, 513, 514, 515, 516, 517, 518, 519, 1086, + 0, 0, 0, 0, 0, 0, 1087, 1088, 1089, 0, + 0, 0, 0, 1090, 0, 1091, 2352, 0, 0, 0, + 1092, 1093, 0, 1094, 1095, 117, 1046, 819, 1047, 1048, + 1049, 1050, 1051, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, + 124, 125, -1119, 126, 127, 128, 0, 0, 0, 0, + -1119, 1052, 0, 0, 129, 130, 131, 0, 132, 133, + 134, 135, 136, 137, 138, 139, 1053, 141, 1054, 1055, + 0, 144, 145, 146, 147, 148, 149, 1056, 789, 150, + 151, 152, 153, 1057, 1058, 156, 0, 157, 158, 159, + 160, 790, 0, 791, 0, 1059, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 0, 173, 174, 175, 176, + 177, 178, 0, 179, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 1060, 191, 192, 1061, 194, 1062, + 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, + 202, 203, 204, 205, 0, 0, 206, 207, 1063, 209, + 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, + 217, 218, 219, 220, 1064, 222, 223, 224, 225, 226, + 227, 792, 1065, 229, 0, 230, 231, 1066, 233, 0, + 234, 0, 235, 236, 0, 237, 238, 239, 240, 241, + 242, 0, 243, 0, 1067, 1068, 246, 247, 0, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, + 267, 268, 269, 270, 271, 272, 273, 274, 1069, 1070, + 0, 1071, 0, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 0, 0, 289, 290, 291, 292, + 0, 293, 294, 295, 296, 297, 298, 299, 300, 1072, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 1073, 323, 1074, 325, 326, 327, 328, 1075, 329, 330, + 331, 332, 1076, 794, 334, 1077, 336, 337, 338, 0, + 339, 340, 0, 0, 1078, 342, 343, 0, 0, 344, + 345, 346, 347, 348, 349, 796, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, + 0, 362, 363, 797, 365, 366, 367, 368, 369, 370, + 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, + 379, 380, 381, 382, 1079, 384, 385, 386, 387, 0, + 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, + 398, 399, 400, 0, 401, 402, 403, 404, 405, 406, + 1080, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, + 425, 426, 427, 428, 429, 0, 430, 431, 432, 1081, + 434, -1119, 435, 436, 437, 438, 439, 440, 441, 442, + 443, 444, 445, 446, 447, 448, 799, 0, 0, 450, + 451, 0, 452, 453, 454, 455, 456, 457, 458, 0, + 459, 1082, 1083, 0, 0, 462, 463, 800, 465, 801, + 1084, 467, 468, 802, 470, 471, 472, 473, 474, 0, + 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, + 482, 483, 484, 485, 486, 487, 1085, 0, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, + 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, + 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, + 517, 518, 519, 1086, 0, 0, 0, 0, 0, 0, + 1087, 1088, 1089, 0, 0, 0, 0, 1090, 0, 1091, + 0, 0, 0, 0, 1092, 1093, 0, 1094, 1095, 1251, + 1046, 819, 1047, 1048, 1049, 1050, 1051, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, - 0, 0, 0, 0, 0, 0, 1003, 0, 0, 130, - 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, - 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, - 149, 0, 0, 150, 151, 152, 153, 154, 155, 156, - 0, 157, 158, 159, 160, 161, 0, 0, 0, 163, - 164, 165, 166, 167, 168, 0, 170, 171, 172, 0, - 173, 174, 175, 176, 177, 178, 0, 0, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, - 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, + 0, 0, 0, 1253, 0, 1052, 0, 0, 1254, 130, + 131, 0, 132, 133, 134, 1255, 136, 137, 138, 139, + 1053, 1256, 1054, 1055, 0, 144, 145, 146, 147, 148, + 149, 1056, 789, 150, 151, 152, 153, 1057, 1058, 156, + 0, 157, 158, 159, 160, 790, 0, 1257, 0, 1258, + 164, 165, 166, 167, 168, 1259, 170, 171, 172, 0, + 173, 174, 175, 176, 177, 178, 0, 1260, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 1060, 191, + 192, 1061, 194, 1062, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, - 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, - 214, 215, 216, -527, 217, 218, 219, 220, 221, 222, - 223, 224, 225, 226, 227, 228, 0, 229, -527, 230, - 231, 232, 233, -527, 234, 0, 235, 0, 0, 0, - 238, 239, 528, 0, 242, 0, 243, 0, 244, 245, + 206, 207, 1063, 209, 210, 0, 211, 212, 213, 0, + 214, 215, 216, 0, 217, 218, 219, 220, 1064, 222, + 223, 224, 225, 226, 227, 792, 1065, 229, 0, 230, + 231, 1066, 233, 0, 234, 0, 235, 1262, 0, 1263, + 238, 239, 1264, 1265, 242, 0, 243, 0, 1067, 1068, 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, - 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, - 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, - 273, 274, 275, 276, -527, 277, 0, 278, 0, 0, - 281, 0, 283, 284, 285, 286, 287, 288, 0, 0, - 289, 0, 291, 0, -527, 293, 294, 295, 296, 297, - 298, 299, 300, 529, 302, 303, 304, 305, 306, 307, + 1266, 256, 257, 258, 259, 0, 260, 261, 262, 263, + 264, 265, 266, 0, 267, 1267, 269, 270, 271, 272, + 273, 274, 1069, 1070, 0, 1071, 0, 278, 1268, 1269, + 281, 1270, 283, 284, 285, 286, 287, 288, 0, 0, + 289, 1271, 291, 1272, 0, 293, 294, 295, 296, 297, + 298, 299, 300, 1273, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, 321, 322, 0, 324, 325, 326, 327, - 328, 0, 329, 330, 0, 332, 0, 333, 334, 335, - 336, 337, 338, -527, 339, 340, 0, 0, 341, 342, - 343, 0, -527, 344, 345, 346, 0, 348, 0, 350, + 318, 319, 320, 321, 1073, 1274, 1074, 325, 326, 327, + 328, 1075, 329, 330, 1275, 332, 1076, 794, 334, 1077, + 336, 337, 338, 0, 339, 340, 0, 0, 1078, 342, + 343, 0, 0, 344, 345, 346, 1276, 348, 1277, 796, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - 361, 0, 0, 0, 0, 362, 363, 364, 0, 366, + 361, 0, 0, 0, 0, 362, 363, 797, 1278, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, - 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, + 376, 377, 0, 378, 379, 380, 381, 382, 1079, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, - 0, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, + 1279, 404, 405, 406, 1080, 408, 409, 410, 411, 412, + 413, 414, 415, 416, 417, 418, 419, 420, 0, 1280, 421, 422, 423, 424, 425, 426, 427, 428, 429, 0, - 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 445, 446, 530, 448, - 449, 0, 0, 450, 451, 0, 452, 0, 454, 455, - 456, 457, 458, 0, 459, 460, 461, 0, 0, 462, - 463, 464, 465, 466, 0, 467, 468, 469, 470, 471, - 472, 473, 474, -527, 0, 475, 476, 477, 0, 478, + 1281, 431, 432, 1081, 434, 0, 435, 436, 437, 438, + 439, 440, 441, 442, 443, 444, 445, 446, 1282, 448, + 799, 0, 0, 450, 451, 0, 452, 1283, 454, 455, + 456, 457, 458, 0, 459, 1082, 1083, 0, 0, 462, + 463, 800, 465, 801, 1084, 467, 468, 1284, 470, 471, + 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, - 488, 0, 489, 0, 491, 492, 493, 494, 495, 496, + 1085, 0, 489, 1286, 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 516, 517, 518, 519, 527, 0, 553, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1161, 0, 118, 119, 120, 121, - 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, - 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, - 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, - 0, 150, 151, 152, 153, 154, 155, 156, 0, 157, - 158, 159, 160, 161, 0, 0, 0, 163, 164, 165, - 166, 167, 168, 0, 170, 171, 172, 0, 173, 174, - 175, 176, 177, 178, 0, 0, 180, 181, 182, 183, - 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, + 513, 514, 515, 516, 517, 518, 519, 1086, 0, 0, + 0, 0, 0, 0, 1087, 1088, 1089, 0, 0, 0, + 0, 1090, 0, 1091, 3091, 0, 0, 0, 1092, 1093, + 0, 1094, 1095, 1251, 1046, 819, 1047, 1048, 1049, 1050, + 1051, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, + 0, 126, 127, 128, 0, 0, 0, 1253, 0, 1052, + 0, 0, 1254, 130, 131, 0, 132, 133, 134, 1255, + 136, 137, 138, 139, 1053, 1256, 1054, 1055, 0, 144, + 145, 146, 147, 148, 149, 1056, 789, 150, 151, 152, + 153, 1057, 1058, 156, 0, 157, 158, 159, 160, 790, + 0, 1257, 0, 1258, 164, 165, 166, 167, 168, 1259, + 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, + 0, 1260, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 1060, 191, 192, 1061, 194, 1062, 195, 0, + 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, + 204, 205, 0, 0, 206, 207, 1063, 209, 210, 0, + 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, + 219, 220, 1064, 222, 223, 224, 225, 226, 227, 792, + 1065, 229, 0, 230, 231, 1066, 233, 0, 234, 0, + 235, 1262, 0, 1263, 238, 239, 1264, 1265, 242, 0, + 243, 0, 1067, 1068, 246, 247, 0, 248, 249, 250, + 251, 252, 253, 254, 1266, 256, 257, 258, 259, 0, + 260, 261, 262, 263, 264, 265, 266, 0, 267, 1267, + 269, 270, 271, 272, 273, 274, 1069, 1070, 0, 1071, + 0, 278, 1268, 1269, 281, 1270, 283, 284, 285, 286, + 287, 288, 0, 0, 289, 1271, 291, 1272, 0, 293, + 294, 295, 296, 297, 298, 299, 300, 1273, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 1073, 1274, + 1074, 325, 326, 327, 328, 1075, 329, 330, 1275, 332, + 1076, 794, 334, 1077, 336, 337, 338, 0, 339, 340, + 0, 0, 1078, 342, 343, 0, 0, 344, 345, 346, + 1276, 348, 1277, 796, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, + 363, 797, 1278, 366, 367, 368, 369, 370, 371, 0, + 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, + 381, 382, 1079, 384, 385, 386, 387, 0, 388, 389, + 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, + 400, 0, 401, 402, 1279, 404, 405, 406, 1080, 408, + 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, + 419, 420, 0, 1280, 421, 422, 423, 424, 425, 426, + 427, 428, 429, 0, 1281, 431, 432, 1081, 434, 0, + 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, + 445, 446, 1282, 448, 799, 0, 0, 450, 451, 0, + 452, 1283, 454, 455, 456, 457, 458, 0, 459, 1082, + 1083, 0, 0, 462, 463, 800, 465, 801, 1084, 467, + 468, 1284, 470, 471, 472, 473, 474, 0, 0, 475, + 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, + 484, 485, 486, 487, 1085, 0, 489, 1286, 491, 492, + 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, + 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, + 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, + 519, 1086, 0, 0, 0, 0, 0, 0, 1087, 1088, + 1089, 0, 0, 0, 0, 1090, 0, 1091, 0, 0, + 0, 0, 1092, 1093, 0, 1094, 1095, 117, 1046, 819, + 1047, 1048, 1049, 1050, 1051, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 1698, 126, 127, 128, 0, 0, + 0, 0, 0, 1052, 0, 0, 129, 130, 131, 0, + 132, 133, 134, 135, 136, 137, 138, 139, 1053, 141, + 1054, 1055, 0, 144, 145, 146, 147, 148, 149, 1056, + 789, 150, 151, 152, 153, 1057, 1058, 156, 0, 157, + 158, 159, 160, 790, 0, 791, 0, 1059, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 1060, 191, 192, 1061, + 194, 1062, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, - 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, - 216, 0, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, - 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, - 528, 0, 242, 0, 243, 0, 244, 245, 246, 247, - 0, 248, 249, 250, 251, 252, 253, 254, 0, 256, + 1063, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 1064, 222, 223, 224, + 225, 226, 227, 792, 1065, 229, 0, 230, 231, 1066, + 233, 0, 234, 0, 235, 236, 0, 237, 238, 239, + 240, 241, 242, 0, 243, 0, 1067, 1068, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, - 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, - 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, - 283, 284, 285, 286, 287, 288, 0, 0, 289, 0, - 291, 0, 0, 293, 294, 295, 296, 297, 298, 299, - 300, 529, 302, 303, 304, 305, 306, 307, 308, 309, + 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 1069, 1070, 0, 1071, 0, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 290, + 291, 292, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 1072, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 0, 324, 325, 326, 327, 328, 0, - 329, 330, 0, 332, 0, 333, 334, 335, 336, 337, - 338, 0, 339, 340, 0, 0, 341, 342, 343, 0, - 0, 344, 345, 346, 0, 348, 0, 350, 351, 352, + 320, 321, 1073, 323, 1074, 325, 326, 327, 328, 1075, + 329, 330, 331, 332, 1076, 794, 334, 1077, 336, 337, + 338, 0, 339, 340, 0, 0, 1078, 342, 343, 0, + 0, 344, 345, 346, 347, 348, 349, 796, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, - 0, 0, 0, 362, 363, 364, 0, 366, 367, 368, + 0, 0, 0, 362, 363, 797, 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, - 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, + 0, 378, 379, 380, 381, 382, 1079, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, - 396, 397, 398, 399, 400, 0, 401, 402, 0, 404, - 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 396, 397, 398, 399, 400, 0, 401, 402, 403, 404, + 405, 406, 1080, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, - 423, 424, 425, 426, 427, 428, 429, 0, 0, 431, - 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, - 441, 442, 443, 444, 445, 446, 530, 448, 449, 0, - 0, 450, 451, 0, 452, 0, 454, 455, 456, 457, - 458, 0, 459, 460, 461, 0, 0, 462, 463, 464, - 465, 466, 0, 467, 468, 469, 470, 471, 472, 473, + 423, 424, 425, 426, 427, 428, 429, 0, 430, 431, + 432, 1081, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 447, 448, 799, 0, + 0, 450, 451, 0, 452, 453, 454, 455, 456, 457, + 458, 0, 459, 1082, 1083, 0, 0, 462, 463, 800, + 465, 801, 1084, 467, 468, 802, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, - 481, 0, 482, 483, 484, 485, 486, 487, 488, 0, - 489, 0, 491, 492, 493, 494, 495, 496, 497, 0, + 481, 0, 482, 483, 484, 485, 486, 487, 1085, 0, + 489, 490, 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, - 515, 516, 517, 518, 519, 968, 0, 0, 0, 0, + 515, 516, 517, 518, 519, 1086, 0, 0, 0, 0, + 0, 0, 1087, 1088, 1089, 0, 0, 0, 0, 1090, + 0, 1091, 0, 0, 0, 0, 1092, 1093, 0, 1094, + 1095, 117, 1713, 819, 1047, 1048, 1049, 1714, 1051, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 2445, 3229, 0, 118, 119, 120, 121, 122, 123, - 124, 125, 0, 126, 127, 128, 3, 4, 0, 564, - 0, 0, 0, 0, 569, 130, 131, 0, 132, 133, - 134, 571, 136, 137, 138, 572, 573, 574, 575, 576, - 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, - 151, 152, 153, 580, 581, 156, 0, 157, 158, 159, - 160, 583, 0, 585, 0, 587, 164, 165, 166, 167, - 168, 588, 170, 171, 172, 0, 173, 174, 175, 176, - 177, 178, 0, 591, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 593, 191, 192, 594, 194, 0, - 195, 0, 196, 197, 198, 199, 200, 201, 14, 15, - 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, - 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, - 217, 218, 219, 220, 604, 222, 223, 224, 225, 226, - 227, 605, 0, 229, 0, 230, 231, 608, 233, 0, - 234, 0, 235, 611, 23, 613, 238, 239, 614, 615, - 242, 0, 243, 0, 618, 619, 246, 247, 0, 248, - 249, 250, 251, 252, 253, 254, 621, 256, 257, 258, - 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, - 267, 624, 625, 270, 271, 272, 273, 274, 626, 627, - 0, 629, 0, 278, 631, 632, 281, 633, 283, 284, - 285, 286, 287, 288, 0, 0, 289, 636, 291, 637, - 0, 293, 294, 295, 296, 297, 298, 299, 300, 639, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, - 640, 641, 642, 325, 326, 327, 643, 0, 329, 330, - 645, 332, 0, 647, 334, 648, 336, 337, 338, 0, - 339, 340, 0, 0, 341, 342, 343, 0, 0, 344, - 345, 654, 655, 348, 656, 657, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, 361, 26, 27, 28, - 0, 362, 363, 662, 663, 366, 367, 664, 369, 370, - 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, - 379, 380, 381, 382, 667, 384, 385, 386, 387, 0, - 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, - 398, 399, 400, 0, 401, 402, 670, 404, 405, 406, - 671, 408, 409, 410, 411, 412, 413, 414, 415, 416, - 417, 418, 419, 420, 33, 673, 421, 422, 423, 424, - 425, 426, 674, 428, 429, 35, 676, 431, 432, 677, - 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, - 443, 444, 445, 446, 679, 448, 680, 37, 0, 450, - 451, 38, 452, 684, 454, 455, 456, 457, 458, 0, - 459, 686, 687, 0, 0, 462, 463, 690, 465, 691, - 0, 467, 468, 693, 470, 471, 472, 473, 474, 0, - 0, 475, 476, 477, 40, 478, 479, 480, 481, 0, - 482, 483, 484, 485, 486, 969, 699, 0, 489, 701, - 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, - 0, 44, 499, 500, 501, 502, 503, 504, 706, 707, - 708, 709, 710, 711, 712, 713, 714, 715, 716, 516, - 517, 518, 519, 0, 117, 45, 553, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 46, - 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, - 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, - 0, 0, 0, 129, 130, 131, 0, 132, 133, 134, - 135, 136, 137, 138, 139, 140, 141, 142, 143, 0, - 144, 145, 146, 147, 148, 149, 0, 789, 150, 151, - 152, 153, 154, 155, 156, 0, 157, 158, 159, 160, - 790, 0, 791, 0, 163, 164, 165, 166, 167, 168, - 169, 170, 171, 172, 0, 173, 174, 175, 176, 177, - 178, 0, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, - 0, 196, 197, 198, 199, 200, 201, 14, 15, 202, - 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, - 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 792, 0, 229, 0, 230, 231, 232, 233, 0, 234, - 0, 235, 236, 23, 237, 238, 239, 240, 241, 242, - 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, - 268, 269, 270, 271, 272, 273, 274, 275, 276, 0, - 277, 0, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 793, 0, 289, 290, 291, 292, 0, - 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, 0, 329, 330, 331, - 332, 0, 794, 334, 335, 336, 337, 338, 0, 339, - 340, 0, 795, 341, 342, 343, 0, 0, 344, 345, - 346, 347, 348, 349, 796, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, 361, 26, 27, 28, 0, - 362, 363, 797, 365, 366, 367, 368, 369, 370, 371, - 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, - 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, - 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, - 399, 400, 0, 401, 402, 403, 404, 405, 406, 407, - 798, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 33, 0, 421, 422, 423, 424, 425, - 426, 427, 428, 429, 35, 430, 431, 432, 433, 434, - 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, - 444, 445, 446, 447, 448, 799, 37, 0, 450, 451, - 38, 452, 453, 454, 455, 456, 457, 458, 0, 459, - 460, 461, 0, 0, 462, 463, 800, 465, 801, 0, - 467, 468, 802, 470, 471, 472, 473, 474, 0, 0, - 475, 476, 477, 40, 478, 479, 480, 481, 0, 482, - 483, 484, 485, 486, 803, 488, 0, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, - 44, 499, 500, 501, 502, 503, 504, 505, 506, 507, - 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, - 518, 519, 0, 117, 45, 553, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 804, 0, + 118, 119, 120, 121, 122, 123, 124, 125, 1715, 126, + 127, 128, 0, 0, 0, 0, 0, 1052, 0, 0, + 129, 130, 131, 0, 132, 133, 134, 135, 136, 137, + 138, 139, 1053, 141, 1054, 1055, 0, 144, 145, 146, + 147, 148, 149, 1056, 789, 150, 151, 152, 153, 1057, + 1058, 156, 0, 157, 158, 159, 160, 790, 0, 791, + 0, 1059, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 0, 173, 174, 175, 176, 177, 178, 0, 179, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 1060, 191, 192, 1061, 194, 1062, 195, 0, 196, 197, + 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, + 0, 0, 206, 207, 1063, 209, 210, 0, 211, 212, + 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, + 1064, 222, 223, 224, 225, 226, 227, 792, 1065, 229, + 0, 230, 231, 1066, 233, 0, 234, 0, 235, 236, + 0, 237, 238, 239, 240, 241, 242, 0, 243, 0, + 1067, 1068, 246, 247, 0, 248, 249, 250, 251, 252, + 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, + 262, 263, 264, 265, 266, 0, 267, 268, 269, 270, + 271, 272, 273, 274, 1069, 1070, 0, 1071, 0, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 0, 0, 289, 290, 291, 292, 0, 293, 294, 295, + 296, 297, 298, 299, 300, 1072, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 1073, 323, 1074, 325, + 326, 327, 328, 1075, 329, 330, 331, 332, 1076, 794, + 334, 1077, 336, 337, 338, 0, 339, 340, 0, 0, + 1078, 342, 343, 0, 0, 344, 345, 346, 347, 348, + 349, 796, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 360, 361, 0, 0, 0, 0, 362, 363, 797, + 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, + 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, + 1079, 384, 385, 386, 387, 0, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, + 401, 402, 403, 404, 405, 406, 1080, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, + 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, + 429, 0, 430, 431, 432, 1081, 434, 0, 435, 436, + 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, + 447, 448, 799, 0, 0, 450, 451, 0, 452, 453, + 454, 455, 456, 457, 458, 0, 459, 1082, 1083, 0, + 0, 462, 463, 800, 465, 801, 1084, 467, 468, 802, + 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, + 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, + 486, 487, 1085, 0, 489, 490, 491, 492, 493, 494, + 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, + 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, + 511, 512, 513, 514, 515, 516, 517, 518, 519, 1086, + 0, 0, 0, 0, 0, 0, 1087, 1088, 1089, 0, + 0, 0, 0, 1090, 0, 1091, 0, 0, 0, 0, + 1092, 1093, 0, 1094, 1095, 117, 1046, 819, 1047, 1048, + 1049, 1050, 1051, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, + 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, + 0, 1052, 0, 0, 129, 130, 131, 0, 132, 133, + 134, 135, 136, 137, 138, 139, 1053, 141, 1054, 1055, + 0, 144, 145, 146, 147, 148, 149, 1056, 789, 150, + 151, 152, 153, 1057, 1058, 156, 0, 157, 158, 159, + 160, 790, 0, 791, 0, 1059, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 0, 173, 174, 175, 176, + 177, 178, 0, 179, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 1060, 191, 192, 1061, 194, 1062, + 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, + 202, 203, 204, 205, 0, 0, 206, 207, 1063, 209, + 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, + 217, 218, 219, 220, 1064, 222, 223, 224, 225, 226, + 227, 792, 1065, 229, 0, 230, 231, 1066, 233, 0, + 234, 0, 235, 236, 1435, 237, 238, 239, 240, 241, + 242, 0, 243, 0, 1067, 1068, 246, 247, 0, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, + 267, 268, 269, 270, 271, 272, 273, 274, 1069, 1070, + 0, 1071, 0, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 0, 0, 289, 290, 291, 292, + 0, 293, 294, 295, 296, 297, 298, 299, 300, 1072, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 1073, 323, 1074, 325, 326, 327, 328, 1075, 329, 330, + 331, 332, 1076, 794, 334, 1077, 336, 337, 338, 0, + 339, 340, 0, 0, 1078, 342, 343, 0, 0, 344, + 345, 346, 347, 348, 349, 796, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, + 0, 362, 363, 797, 365, 366, 367, 368, 369, 370, + 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, + 379, 380, 381, 382, 1079, 384, 385, 386, 387, 0, + 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, + 398, 399, 400, 0, 401, 402, 403, 404, 405, 406, + 1080, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, + 425, 426, 427, 428, 429, 0, 430, 431, 432, 1081, + 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, + 443, 444, 445, 446, 447, 448, 799, 0, 0, 450, + 451, 0, 452, 453, 454, 455, 456, 457, 458, 0, + 459, 1082, 1083, 0, 0, 462, 463, 800, 465, 801, + 1084, 467, 468, 802, 470, 471, 472, 473, 474, 0, + 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, + 482, 483, 484, 485, 486, 487, 1085, 0, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, + 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, + 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, + 517, 518, 519, 1086, 0, 0, 0, 0, 0, 0, + 1087, 1088, 1089, 0, 0, 0, 0, 1090, 0, 1091, + 0, 0, 0, 0, 1092, 1093, 0, 1094, 1095, 117, + 1046, 819, 1047, 1048, 1049, 1050, 1051, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, + 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, + 0, 0, 0, 0, 0, 1052, 0, 0, 129, 130, + 131, 0, 132, 133, 134, 135, 136, 137, 138, 139, + 1053, 141, 1054, 1055, 0, 144, 145, 146, 147, 148, + 149, 1056, 789, 150, 151, 152, 153, 1057, 1058, 156, + 0, 157, 158, 159, 160, 790, 0, 791, 0, 1059, + 164, 165, 166, 167, 168, 169, 170, 171, 172, 0, + 173, 174, 175, 176, 177, 178, 0, 179, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 1060, 191, + 192, 1061, 194, 1062, 195, 0, 196, 197, 198, 199, + 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, + 206, 207, 1063, 209, 210, 0, 211, 212, 213, 0, + 214, 215, 216, 0, 217, 218, 219, 220, 1064, 222, + 223, 224, 225, 226, 227, 792, 1065, 229, 0, 230, + 231, 1066, 233, 0, 234, 0, 235, 236, 0, 237, + 238, 239, 240, 241, 242, 0, 243, 0, 1067, 1068, + 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 0, 260, 261, 262, 263, + 264, 265, 266, 0, 267, 268, 269, 270, 271, 272, + 273, 274, 1069, 1070, 0, 1071, 0, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 0, 0, + 289, 290, 291, 292, 0, 293, 294, 295, 296, 297, + 298, 299, 300, 1072, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 1073, 323, 1074, 325, 326, 327, + 328, 1075, 329, 330, 331, 332, 1076, 794, 334, 1077, + 336, 337, 338, 0, 339, 340, 0, 0, 1078, 342, + 343, 0, 0, 344, 345, 346, 347, 348, 349, 796, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + 361, 0, 0, 0, 0, 362, 363, 797, 365, 366, + 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, + 376, 377, 0, 378, 379, 380, 381, 382, 1079, 384, + 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, + 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, + 403, 404, 405, 406, 1080, 408, 409, 410, 411, 412, + 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, + 421, 422, 423, 424, 425, 426, 427, 428, 429, 0, + 430, 431, 432, 1081, 434, 0, 435, 436, 437, 438, + 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, + 799, 0, 0, 450, 451, 0, 452, 453, 454, 455, + 456, 457, 458, 0, 459, 1082, 1083, 0, 0, 462, + 463, 800, 465, 801, 1084, 467, 468, 802, 470, 471, + 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, + 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, + 1085, 0, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, + 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, + 513, 514, 515, 516, 517, 518, 519, 1086, 0, 0, + 0, 0, 0, 0, 1087, 1088, 1089, 0, 0, 0, + 0, 1090, 0, 1091, 2065, 0, 0, 0, 1092, 1093, + 0, 1094, 1095, 117, 1046, 819, 1047, 1048, 1049, 1050, + 1051, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, - 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, + 0, 126, 127, 128, 0, 0, 0, 0, 0, 1052, 0, 0, 129, 130, 131, 0, 132, 133, 134, 135, - 136, 137, 138, 139, 140, 141, 142, 143, 0, 144, - 145, 146, 147, 148, 149, 0, 789, 150, 151, 152, - 153, 154, 155, 156, 0, 157, 158, 159, 160, 790, - 0, 791, 0, 163, 164, 165, 166, 167, 168, 169, + 136, 137, 138, 139, 1053, 141, 1054, 1055, 0, 144, + 145, 146, 147, 148, 149, 1056, 789, 150, 151, 152, + 153, 1057, 1058, 156, 0, 157, 158, 159, 160, 790, + 0, 791, 0, 1059, 164, 165, 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, + 188, 189, 1060, 191, 192, 1061, 194, 1062, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, - 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, + 204, 205, 0, 0, 206, 207, 1063, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, - 219, 220, 221, 222, 223, 224, 225, 226, 227, 792, - 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, + 219, 220, 1064, 222, 223, 224, 225, 226, 227, 792, + 1065, 229, 0, 230, 231, 1066, 233, 0, 234, 0, 235, 236, 0, 237, 238, 239, 240, 241, 242, 0, - 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, + 243, 0, 1067, 1068, 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 268, - 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, + 269, 270, 271, 272, 273, 274, 1069, 1070, 0, 1071, 0, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 793, 0, 289, 290, 291, 292, 0, 293, - 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, + 287, 288, 0, 0, 289, 290, 291, 292, 0, 293, + 294, 295, 296, 297, 298, 299, 300, 1072, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, - 324, 325, 326, 327, 328, 0, 329, 330, 331, 332, - 0, 794, 334, 335, 336, 337, 338, 0, 339, 340, - 0, 795, 341, 342, 343, 0, 0, 344, 345, 346, + 314, 315, 316, 317, 318, 319, 320, 321, 1073, 323, + 1074, 325, 326, 327, 328, 1075, 329, 330, 331, 332, + 1076, 794, 334, 1077, 336, 337, 338, 0, 339, 340, + 0, 0, 1078, 342, 343, 0, 0, 344, 345, 346, 347, 348, 349, 796, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, 797, 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, - 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, + 381, 382, 1079, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, - 400, 0, 401, 402, 403, 404, 405, 406, 407, 798, + 400, 0, 401, 402, 403, 404, 405, 406, 1080, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, 426, - 427, 428, 429, 0, 430, 431, 432, 433, 434, 0, + 427, 428, 429, 0, 430, 431, 432, 1081, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, - 445, 446, 447, 448, 799, 0, 0, 450, 451, 0, - 452, 453, 454, 455, 456, 457, 458, 0, 459, 460, - 461, 0, 0, 462, 463, 800, 465, 801, 0, 467, + 445, 446, 447, 448, 799, 0, 0, 450, 451, 2701, + 452, 453, 454, 455, 456, 457, 458, 0, 459, 1082, + 1083, 0, 0, 462, 463, 800, 465, 801, 1084, 467, 468, 802, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, - 484, 485, 486, 803, 488, 0, 489, 490, 491, 492, + 484, 485, 486, 487, 1085, 0, 489, 490, 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, - 519, 117, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 804, 0, 0, - 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, - 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, + 519, 1086, 0, 0, 0, 0, 0, 0, 1087, 1088, + 1089, 0, 0, 0, 0, 1090, 0, 1091, 0, 0, + 0, 0, 1092, 1093, 0, 1094, 1095, 117, 1046, 819, + 1047, 1048, 1049, 1050, 1051, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, + 0, 0, 0, 1052, 0, 0, 129, 130, 131, 0, + 132, 133, 134, 135, 136, 137, 138, 139, 1053, 141, + 1054, 1055, 0, 144, 145, 146, 147, 148, 149, 1056, + 789, 150, 151, 152, 153, 1057, 1058, 156, 0, 157, + 158, 159, 160, 790, 0, 791, 0, 1059, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 1060, 191, 192, 1061, + 194, 1062, 195, 0, 196, 197, 198, 199, 200, 201, + 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, + 1063, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 1064, 222, 223, 224, + 225, 226, 227, 792, 1065, 229, 0, 230, 231, 1066, + 233, 0, 234, 0, 235, 236, 0, 237, 238, 239, + 240, 241, 242, 0, 243, 0, 1067, 1068, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, + 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 1069, 1070, 0, 1071, 0, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 290, + 291, 292, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 1072, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 1073, 323, 1074, 325, 326, 327, 328, 1075, + 329, 330, 331, 332, 1076, 794, 334, 1077, 336, 337, + 338, 0, 339, 340, 0, 0, 1078, 342, 343, 0, + 0, 344, 345, 346, 347, 348, 349, 796, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, + 0, 0, 0, 362, 363, 797, 365, 366, 367, 368, + 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, + 0, 378, 379, 380, 381, 382, 1079, 384, 385, 386, + 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 0, 401, 402, 403, 404, + 405, 406, 1080, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 0, 430, 431, + 432, 1081, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 447, 448, 799, 0, + 0, 450, 451, 0, 452, 453, 454, 455, 456, 457, + 458, 0, 459, 1082, 1083, 0, 0, 462, 463, 800, + 465, 801, 1084, 467, 468, 802, 470, 471, 472, 473, + 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 487, 1085, 0, + 489, 490, 491, 492, 493, 494, 495, 496, 497, 0, + 2820, 498, 0, 0, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 1086, 0, 0, 0, 0, + 0, 0, 1087, 1088, 1089, 0, 0, 0, 0, 1090, + 0, 1091, 0, 0, 0, 0, 1092, 1093, 0, 1094, + 1095, 117, 1046, 819, 1047, 1048, 1049, 1050, 1051, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 118, 119, 120, 121, 122, 123, 124, 125, 3035, 126, + 127, 128, 0, 0, 0, 0, 0, 1052, 0, 0, 129, 130, 131, 0, 132, 133, 134, 135, 136, 137, - 138, 139, 140, 141, 142, 143, 0, 144, 145, 146, - 147, 148, 149, 0, 789, 150, 151, 152, 153, 154, - 155, 156, 0, 157, 158, 159, 160, 790, 0, 791, - 0, 163, 164, 165, 166, 167, 168, 169, 170, 171, + 138, 139, 1053, 141, 1054, 1055, 0, 144, 145, 146, + 147, 148, 149, 1056, 789, 150, 151, 152, 153, 1057, + 1058, 156, 0, 157, 158, 159, 160, 790, 0, 791, + 0, 1059, 164, 165, 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, + 180, 3036, 182, 183, 184, 185, 186, 187, 188, 189, + 1060, 191, 192, 1061, 194, 1062, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, - 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, + 0, 0, 206, 207, 1063, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 227, 792, 0, 229, - 0, 230, 231, 232, 233, 0, 234, 0, 235, 236, + 1064, 222, 223, 224, 225, 226, 227, 792, 1065, 229, + 0, 230, 231, 1066, 233, 0, 234, 0, 235, 236, 0, 237, 238, 239, 240, 241, 242, 0, 243, 0, - 244, 245, 246, 247, 0, 248, 249, 250, 251, 252, + 3037, 1068, 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, + 271, 272, 273, 274, 1069, 1070, 0, 1071, 0, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 0, 0, 289, 290, 291, 292, 0, 293, 294, 295, - 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 296, 297, 298, 299, 300, 1072, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, - 326, 327, 328, 0, 329, 330, 331, 332, 0, 794, - 334, 335, 336, 337, 338, 0, 339, 340, 0, 0, - 341, 342, 343, 0, 0, 344, 345, 346, 347, 348, + 316, 317, 318, 319, 320, 321, 1073, 323, 1074, 325, + 326, 327, 328, 1075, 329, 330, 331, 332, 1076, 794, + 334, 1077, 336, 337, 338, 0, 339, 340, 0, 0, + 1078, 342, 343, 0, 0, 344, 345, 346, 347, 348, 349, 796, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, 797, 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, - 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, + 1079, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, - 401, 402, 403, 404, 405, 406, 407, 798, 409, 410, + 401, 402, 403, 404, 405, 3038, 1080, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, - 429, 0, 430, 431, 432, 433, 434, 0, 435, 436, + 429, 0, 430, 431, 432, 1081, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 799, 0, 0, 450, 451, 0, 452, 453, - 454, 455, 456, 457, 458, 0, 459, 460, 461, 0, - 0, 462, 463, 800, 465, 801, 0, 467, 468, 802, + 454, 455, 456, 457, 458, 0, 459, 1082, 1083, 0, + 0, 462, 463, 800, 465, 801, 1084, 467, 468, 802, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, - 486, 487, 488, 0, 489, 490, 491, 492, 493, 494, + 486, 487, 1085, 0, 489, 490, 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 516, 517, 518, 519, 117, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 46, 0, 0, 118, 119, + 511, 512, 513, 514, 515, 516, 517, 518, 519, 1086, + 0, 0, 0, 0, 0, 0, 1087, 1088, 1089, 0, + 0, 0, 0, 1090, 0, 3039, 0, 0, 0, 0, + 1092, 1093, 0, 1094, 1095, 117, 1046, 819, 1047, 1048, + 1049, 1050, 1051, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, + 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, + 0, 1052, 0, 0, 129, 130, 131, 0, 132, 133, + 134, 135, 136, 137, 138, 139, 1053, 141, 1054, 1055, + 0, 144, 145, 146, 147, 148, 149, 1056, 789, 150, + 151, 152, 153, 1057, 1058, 156, 0, 157, 158, 159, + 160, 790, 0, 791, 0, 1059, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 0, 173, 174, 175, 176, + 177, 178, 0, 179, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 1060, 191, 192, 1061, 194, 1062, + 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, + 202, 203, 204, 205, 0, 0, 206, 207, 1063, 209, + 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, + 217, 218, 219, 220, 1064, 222, 223, 224, 225, 226, + 227, 792, 1065, 229, 0, 230, 231, 1066, 233, 0, + 234, 0, 235, 236, 0, 237, 238, 239, 240, 241, + 242, 0, 243, 0, 1067, 1068, 246, 247, 0, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, + 267, 268, 269, 270, 271, 272, 273, 274, 1069, 1070, + 0, 1071, 0, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 0, 0, 289, 290, 291, 292, + 0, 293, 294, 295, 296, 297, 298, 299, 300, 1072, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 1073, 323, 1074, 325, 326, 327, 328, 1075, 329, 330, + 331, 332, 1076, 794, 334, 1077, 336, 337, 338, 0, + 339, 340, 0, 0, 1078, 342, 343, 0, 0, 344, + 345, 346, 347, 348, 349, 796, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, + 0, 362, 363, 797, 365, 366, 367, 368, 369, 370, + 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, + 379, 380, 381, 382, 1079, 384, 385, 386, 387, 0, + 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, + 398, 399, 400, 0, 401, 402, 403, 404, 405, 406, + 1080, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, + 425, 426, 427, 428, 429, 0, 430, 431, 432, 1081, + 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, + 443, 444, 445, 446, 447, 448, 799, 0, 0, 450, + 451, 3187, 452, 453, 454, 455, 456, 457, 458, 0, + 459, 1082, 1083, 0, 0, 462, 463, 800, 465, 801, + 1084, 467, 468, 802, 470, 471, 472, 473, 474, 0, + 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, + 482, 483, 484, 485, 486, 487, 1085, 0, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, + 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, + 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, + 517, 518, 519, 1086, 0, 0, 0, 0, 0, 0, + 1087, 1088, 1089, 0, 0, 0, 0, 1090, 0, 1091, + 0, 0, 0, 0, 1092, 1093, 0, 1094, 1095, 117, + 1046, 819, 1047, 1048, 1049, 1050, 1051, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, - 0, 0, 0, 0, 0, 0, 0, 0, 129, 130, + 0, 0, 0, 0, 0, 1052, 0, 0, 129, 130, 131, 0, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 0, 144, 145, 146, 147, 148, - 149, 0, 789, 150, 151, 152, 153, 154, 155, 156, - 0, 157, 158, 159, 160, 790, 0, 791, 0, 163, + 1053, 141, 1054, 1055, 0, 144, 145, 146, 147, 148, + 149, 1056, 789, 150, 151, 152, 153, 1057, 1058, 156, + 0, 157, 158, 159, 160, 790, 0, 791, 0, 1059, 164, 165, 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, - 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, + 182, 183, 184, 185, 186, 187, 188, 189, 1060, 191, + 192, 1061, 194, 1062, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, - 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, - 214, 215, 216, 0, 217, 218, 219, 220, 221, 222, - 223, 224, 225, 226, 227, 792, 0, 229, 0, 230, - 231, 232, 233, 0, 234, 0, 235, 236, 0, 237, - 238, 239, 240, 241, 242, 0, 243, 0, 244, 245, + 206, 207, 1063, 209, 210, 0, 211, 212, 213, 0, + 214, 215, 216, 0, 217, 218, 219, 220, 1064, 222, + 223, 224, 225, 226, 227, 792, 1065, 229, 0, 230, + 231, 1066, 233, 0, 234, 0, 235, 236, 0, 237, + 238, 239, 240, 241, 242, 0, 243, 0, 1067, 1068, 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 0, 277, 0, 278, 279, 280, + 273, 274, 1069, 1070, 0, 1071, 0, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 0, 0, 289, 290, 291, 292, 0, 293, 294, 295, 296, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 298, 299, 300, 1072, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, - 328, 0, 329, 330, 331, 332, 0, 794, 334, 335, - 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, + 318, 319, 320, 321, 1073, 323, 1074, 325, 326, 327, + 328, 1075, 329, 330, 331, 332, 1076, 794, 334, 1077, + 336, 337, 338, 0, 339, 340, 0, 0, 1078, 342, 343, 0, 0, 344, 345, 346, 347, 348, 349, 796, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, 797, 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, - 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, + 376, 377, 0, 378, 379, 380, 381, 382, 1079, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, + 403, 404, 405, 406, 1080, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, 429, 0, - 430, 431, 432, 433, 434, 0, 435, 436, 437, 438, + 430, 431, 432, 1081, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, - 799, 0, 0, 450, 451, 0, 452, 453, 454, 455, - 456, 457, 458, 0, 459, 460, 461, 0, 0, 462, - 463, 800, 465, 801, 0, 467, 468, 802, 470, 471, + 799, 0, 0, 450, 451, 3325, 452, 453, 454, 455, + 456, 457, 458, 0, 459, 1082, 1083, 0, 0, 462, + 463, 800, 465, 801, 1084, 467, 468, 802, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, - 488, 0, 489, 490, 491, 492, 493, 494, 495, 496, + 1085, 0, 489, 490, 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 516, 517, 518, 519, 527, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 3317, 0, 0, 118, 119, 120, 121, + 513, 514, 515, 516, 517, 518, 519, 1086, 0, 0, + 0, 0, 0, 0, 1087, 1088, 1089, 0, 0, 0, + 0, 1090, 0, 1091, 0, 0, 0, 0, 1092, 1093, + 0, 1094, 1095, 117, 1046, 819, 1047, 1048, 1049, 1050, + 1051, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, + 0, 126, 127, 128, 0, 0, 0, 0, 0, 1052, + 0, 0, 129, 130, 131, 0, 132, 133, 134, 135, + 136, 137, 138, 139, 1053, 141, 1054, 1055, 0, 144, + 145, 146, 147, 148, 149, 1056, 789, 150, 151, 152, + 153, 1057, 1058, 156, 0, 157, 158, 159, 160, 790, + 0, 791, 0, 1059, 164, 165, 166, 167, 168, 169, + 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, + 0, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 1060, 191, 192, 1061, 194, 1062, 195, 0, + 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, + 204, 205, 0, 0, 206, 207, 1063, 209, 210, 0, + 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, + 219, 220, 1064, 222, 223, 224, 225, 226, 227, 792, + 1065, 229, 0, 230, 231, 1066, 233, 0, 234, 0, + 235, 236, 0, 237, 238, 239, 240, 241, 242, 0, + 243, 0, 1067, 1068, 246, 247, 0, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 0, + 260, 261, 262, 263, 264, 265, 266, 0, 267, 268, + 269, 270, 271, 272, 273, 274, 1069, 1070, 0, 1071, + 0, 278, 279, 280, 281, 282, 283, 284, 285, 286, + 287, 288, 0, 0, 289, 290, 291, 292, 0, 293, + 294, 295, 296, 297, 298, 299, 300, 1072, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 1073, 323, + 1074, 325, 326, 327, 328, 1075, 329, 330, 331, 332, + 1076, 794, 334, 1077, 336, 337, 338, 0, 339, 340, + 0, 0, 1078, 342, 343, 0, 0, 344, 345, 346, + 347, 348, 349, 796, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, + 363, 797, 365, 366, 367, 368, 369, 370, 371, 0, + 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, + 381, 382, 1079, 384, 385, 386, 387, 0, 388, 389, + 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, + 400, 0, 401, 402, 403, 404, 405, 406, 1080, 408, + 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, + 419, 420, 0, 0, 421, 422, 423, 424, 425, 426, + 427, 428, 429, 0, 430, 431, 432, 1081, 434, 0, + 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, + 445, 446, 447, 448, 799, 0, 0, 450, 451, 0, + 452, 453, 454, 455, 456, 457, 458, 0, 459, 1082, + 1083, 0, 0, 462, 463, 800, 465, 801, 1084, 467, + 468, 802, 470, 471, 472, 473, 474, 0, 0, 475, + 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, + 484, 485, 486, 487, 1085, 0, 489, 490, 491, 492, + 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, + 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, + 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, + 519, 1086, 0, 0, 0, 0, 0, 0, 1087, 1088, + 1089, 0, 0, 0, 0, 1090, 0, 1091, 0, 0, + 0, 0, 1092, 1093, 0, 1094, 1095, 117, 1046, 819, + 1047, 1048, 1049, 1050, 1051, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, - 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, - 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, - 0, 150, 151, 152, 153, 154, 155, 156, 0, 157, - 158, 159, 160, 161, 0, 0, 0, 163, 164, 165, - 166, 167, 168, 0, 170, 171, 172, 0, 173, 174, - 175, 176, 177, 178, 0, 0, 180, 181, 182, 183, - 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, - 14, 15, 202, 203, 204, 205, 0, 0, 206, 207, - 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, - 216, 0, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, - 233, 0, 234, 0, 235, 0, 23, 0, 238, 239, - 528, 0, 242, 0, 243, 0, 244, 245, 246, 247, - 0, 248, 249, 250, 251, 252, 253, 254, 0, 256, + 0, 0, 0, 1052, 0, 0, 129, 130, 131, 0, + 132, 133, 134, 135, 136, 137, 138, 139, 1053, 141, + 1054, 1055, 0, 144, 145, 146, 147, 148, 149, 1056, + 789, 150, 151, 152, 153, 1057, 1058, 156, 0, 157, + 158, 159, 160, 790, 0, 791, 0, 1059, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 1060, 191, 192, 1061, + 194, 1062, 195, 0, 196, 197, 198, 199, 200, 201, + 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, + 1063, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 1064, 222, 223, 224, + 225, 226, 227, 792, 1065, 229, 0, 230, 231, 1066, + 233, 0, 234, 0, 235, 236, 0, 237, 238, 239, + 240, 241, 242, 0, 243, 0, 1067, 1068, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, - 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, - 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, - 283, 284, 285, 286, 287, 288, 0, 0, 289, 0, - 291, 0, 0, 293, 294, 295, 296, 297, 298, 299, - 300, 529, 302, 303, 304, 305, 306, 307, 308, 309, + 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 1069, 1070, 0, 1071, 0, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 290, + 291, 292, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 1072, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 0, 324, 325, 326, 327, 328, 0, - 329, 330, 0, 332, 0, 333, 334, 335, 336, 337, - 338, 0, 339, 340, 0, 0, 341, 342, 343, 0, - 0, 344, 345, 346, 0, 348, 0, 350, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 360, 361, 26, - 27, 28, 0, 362, 363, 364, 0, 366, 367, 368, + 320, 321, 1073, 323, 1074, 325, 326, 327, 328, 1075, + 329, 330, 331, 332, 1076, 794, 334, 1077, 336, 337, + 338, 0, 339, 340, 0, 0, 1078, 342, 343, 0, + 0, 344, 345, 346, 347, 348, 349, 796, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, + 0, 0, 0, 362, 363, 797, 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, - 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, + 0, 378, 379, 380, 381, 382, 1079, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, - 396, 397, 398, 399, 400, 0, 401, 402, 0, 404, - 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, - 415, 416, 417, 418, 419, 420, 33, 0, 421, 422, - 423, 424, 425, 426, 427, 428, 429, 35, 0, 431, - 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, - 441, 442, 443, 444, 445, 446, 530, 448, 449, 37, - 0, 450, 451, 38, 452, 0, 454, 455, 456, 457, - 458, 0, 459, 460, 461, 0, 0, 462, 463, 464, - 465, 466, 0, 467, 468, 469, 470, 471, 472, 473, - 474, 0, 0, 475, 476, 477, 40, 478, 479, 480, - 481, 0, 482, 483, 484, 485, 486, 803, 488, 0, - 489, 0, 491, 492, 493, 494, 495, 496, 497, 0, - 0, 498, 0, 44, 499, 500, 501, 502, 503, 504, + 396, 397, 398, 399, 400, 0, 401, 402, 403, 404, + 405, 406, 1080, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 0, 430, 431, + 432, 1081, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 447, 448, 799, 0, + 0, 450, 451, 0, 452, 453, 454, 455, 456, 457, + 458, 0, 459, 1082, 1083, 0, 0, 462, 463, 800, + 465, 801, 1084, 467, 468, 802, 470, 471, 472, 473, + 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 487, 1085, 0, + 489, 490, 491, 492, 493, 494, 495, 496, 497, 0, + 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, - 515, 516, 517, 518, 519, 527, 0, 45, 0, 0, + 515, 516, 517, 518, 519, 1086, 0, 0, 0, 0, + 0, 0, 1718, 1719, 1089, 0, 0, 0, 0, 1090, + 0, 1091, 0, 0, 0, 0, 1092, 1093, 0, 1094, + 1095, 117, 2202, 819, 1047, 1048, 1049, 1050, 1051, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 46, 0, 0, 118, 119, 120, 121, 122, 123, - 124, 125, 890, 126, 127, 128, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, - 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, - 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, - 151, 152, 153, 154, 155, 156, 0, 157, 158, 159, - 160, 161, 0, 0, 0, 163, 164, 165, 166, 167, - 168, 0, 170, 171, 172, 0, 173, 174, 175, 176, - 177, 178, 0, 0, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 190, 191, 192, 193, 194, 0, + 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, + 127, 128, 0, 0, 0, 0, 0, 1052, 0, 0, + 129, 130, 131, 0, 132, 133, 134, 135, 136, 137, + 138, 139, 1053, 141, 1054, 1055, 0, 144, 145, 146, + 147, 148, 149, 1056, 789, 150, 151, 152, 153, 1057, + 1058, 156, 0, 157, 158, 159, 160, 790, 0, 791, + 0, 1059, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 0, 173, 174, 175, 176, 177, 178, 0, 179, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 1060, 191, 192, 1061, 194, 1062, 195, 0, 196, 197, + 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, + 0, 0, 206, 207, 1063, 209, 210, 0, 211, 212, + 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, + 1064, 222, 223, 224, 225, 226, 227, 792, 1065, 229, + 0, 230, 231, 1066, 233, 0, 234, 0, 235, 236, + 0, 237, 238, 239, 240, 241, 242, 0, 243, 0, + 1067, 1068, 246, 247, 0, 248, 249, 250, 251, 252, + 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, + 262, 263, 264, 265, 266, 0, 267, 268, 269, 270, + 271, 272, 273, 274, 1069, 1070, 0, 1071, 0, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 0, 0, 289, 290, 291, 292, 0, 293, 294, 295, + 296, 297, 298, 299, 300, 1072, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 1073, 323, 1074, 325, + 326, 327, 328, 1075, 329, 330, 331, 332, 1076, 794, + 334, 1077, 336, 337, 338, 0, 339, 340, 0, 0, + 1078, 342, 343, 0, 0, 344, 345, 346, 347, 348, + 349, 796, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 360, 361, 0, 0, 0, 0, 362, 363, 797, + 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, + 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, + 1079, 384, 385, 386, 387, 0, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, + 401, 402, 403, 404, 405, 406, 1080, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, + 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, + 429, 0, 430, 431, 432, 1081, 434, 0, 435, 436, + 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, + 447, 448, 799, 0, 0, 450, 451, 0, 452, 453, + 454, 455, 456, 457, 458, 0, 459, 1082, 1083, 0, + 0, 462, 463, 800, 465, 801, 1084, 467, 468, 802, + 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, + 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, + 486, 487, 1085, 0, 489, 490, 491, 492, 493, 494, + 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, + 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, + 511, 512, 513, 514, 515, 516, 517, 518, 519, 1086, + 0, 0, 0, 0, 0, 0, 1087, 1088, 1089, 0, + 0, 0, 0, 1090, 0, 1091, 0, 0, 0, 0, + 1092, 1093, 0, 1094, 1095, 117, 1046, 819, 1047, 1048, + 1049, 1050, 1051, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, + 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, + 0, 1052, 0, 0, 129, 130, 131, 0, 132, 133, + 134, 135, 136, 137, 138, 139, 1053, 141, 1054, 1055, + 0, 144, 145, 146, 147, 148, 149, 1056, 789, 150, + 151, 152, 153, 1057, 1058, 156, 0, 157, 158, 159, + 160, 790, 0, 791, 0, 1059, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 0, 173, 174, 175, 176, + 177, 178, 0, 179, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 1060, 191, 192, 1061, 194, 1062, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, - 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, + 202, 203, 204, 205, 0, 0, 206, 207, 1063, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, - 234, 0, 235, 0, 23, 0, 238, 239, 528, 0, - 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, - 249, 250, 251, 252, 253, 254, 0, 256, 257, 258, + 217, 218, 219, 220, 1064, 222, 223, 224, 225, 226, + 227, 792, 1065, 229, 0, 230, 231, 1066, 233, 0, + 234, 0, 235, 236, 0, 237, 238, 239, 240, 241, + 242, 0, 243, 0, 1067, 1068, 246, 247, 0, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, - 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, - 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, - 285, 286, 287, 288, 0, 0, 289, 0, 291, 0, - 0, 293, 294, 295, 296, 297, 298, 299, 300, 529, + 267, 268, 269, 270, 271, 272, 273, 274, 1069, 1070, + 0, 1071, 0, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 0, 0, 289, 290, 291, 292, + 0, 293, 294, 295, 296, 297, 298, 299, 300, 1072, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, - 322, 0, 324, 325, 326, 327, 328, 0, 329, 330, - 0, 332, 0, 333, 334, 335, 336, 337, 338, 0, - 339, 340, 0, 0, 341, 342, 343, 0, 0, 344, - 345, 346, 0, 348, 0, 350, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, 361, 26, 27, 28, - 0, 362, 363, 364, 0, 366, 367, 368, 369, 370, + 1073, 323, 1074, 325, 326, 327, 328, 1075, 329, 330, + 331, 332, 1076, 794, 334, 1077, 336, 337, 338, 0, + 339, 340, 0, 0, 1078, 342, 343, 0, 0, 344, + 345, 346, 347, 348, 349, 796, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, + 0, 362, 363, 797, 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, - 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, + 379, 380, 381, 382, 1079, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, - 398, 399, 400, 0, 401, 402, 0, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, - 417, 418, 419, 420, 33, 0, 421, 422, 423, 424, - 425, 426, 427, 428, 429, 0, 0, 431, 432, 433, + 398, 399, 400, 0, 401, 402, 403, 404, 405, 406, + 1080, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, + 425, 426, 427, 428, 429, 0, 430, 431, 432, 1081, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, - 443, 444, 445, 446, 530, 448, 449, 0, 0, 450, - 451, 38, 452, 0, 454, 455, 456, 457, 458, 0, - 459, 891, 461, 0, 0, 892, 463, 464, 465, 466, - 0, 467, 468, 469, 470, 471, 472, 473, 474, 0, - 0, 475, 476, 477, 40, 478, 479, 480, 481, 0, - 482, 483, 484, 485, 486, 803, 488, 0, 489, 0, + 443, 444, 445, 446, 447, 448, 799, 0, 0, 450, + 451, 0, 452, 453, 454, 455, 456, 457, 458, 0, + 459, 1082, 1083, 0, 0, 462, 463, 800, 465, 801, + 1084, 467, 468, 802, 470, 471, 472, 473, 474, 0, + 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, + 482, 483, 484, 485, 486, 487, 1085, 0, 489, 490, 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, - 0, 44, 499, 500, 501, 502, 503, 504, 505, 506, + 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, - 517, 518, 519, 527, 0, 45, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 46, + 517, 518, 519, 1086, 0, 0, 0, 0, 0, 0, + 1087, 2289, 1089, 0, 0, 0, 0, 1090, 0, 1091, + 0, 0, 0, 0, 1092, 1093, 0, 1094, 1095, 117, + 1046, 819, 1047, 1048, 1049, 1050, 1051, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, + 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, + 0, 0, 0, 0, 0, 1052, 0, 0, 129, 130, + 131, 0, 132, 133, 134, 135, 136, 137, 138, 139, + 1053, 141, 1054, 1055, 0, 144, 145, 146, 147, 148, + 149, 1056, 789, 150, 151, 152, 153, 1057, 1058, 156, + 0, 157, 158, 159, 160, 790, 0, 791, 0, 1059, + 164, 165, 166, 167, 168, 169, 170, 171, 172, 0, + 173, 174, 175, 176, 177, 178, 0, 179, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 1060, 191, + 192, 1061, 194, 1062, 195, 0, 196, 197, 198, 199, + 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, + 206, 207, 1063, 209, 210, 0, 211, 212, 213, 0, + 214, 215, 216, 0, 217, 218, 219, 220, 1064, 222, + 223, 224, 225, 226, 227, 792, 1065, 229, 0, 230, + 231, 1066, 233, 0, 234, 0, 235, 236, 0, 237, + 238, 239, 240, 241, 242, 0, 243, 0, 1067, 1068, + 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 0, 260, 261, 262, 263, + 264, 265, 266, 0, 267, 268, 269, 270, 271, 272, + 273, 274, 1069, 1070, 0, 1071, 0, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 0, 0, + 289, 290, 291, 292, 0, 293, 294, 295, 296, 297, + 298, 299, 300, 1072, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 1073, 323, 1074, 325, 326, 327, + 328, 1075, 329, 330, 331, 332, 1076, 794, 334, 1077, + 336, 337, 338, 0, 339, 340, 0, 0, 1078, 342, + 343, 0, 0, 344, 345, 346, 347, 348, 349, 796, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + 361, 0, 0, 0, 0, 362, 363, 797, 365, 366, + 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, + 376, 377, 0, 378, 379, 380, 381, 382, 1079, 384, + 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, + 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, + 403, 404, 405, 406, 1080, 408, 409, 410, 411, 412, + 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, + 421, 422, 423, 424, 425, 426, 427, 428, 429, 0, + 430, 431, 432, 1081, 434, 0, 435, 436, 437, 438, + 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, + 799, 0, 0, 450, 451, 0, 452, 453, 454, 455, + 456, 457, 458, 0, 459, 1082, 1083, 0, 0, 462, + 463, 800, 465, 801, 1084, 467, 468, 802, 470, 471, + 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, + 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, + 1085, 0, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, + 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, + 513, 514, 515, 516, 517, 518, 519, 1086, 0, 0, + 0, 0, 0, 0, 1087, 1088, 1089, 0, 0, 0, + 0, 1090, 0, 2504, 0, 0, 0, 0, 1092, 1093, + 0, 1094, 1095, 117, 1046, 819, 1047, 1048, 1049, 1050, + 1051, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, - 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, - 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, - 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, - 153, 154, 155, 156, 0, 157, 158, 159, 160, 161, - 0, 0, 0, 163, 164, 165, 166, 167, 168, 0, + 0, 126, 127, 128, 0, 0, 0, 0, 0, 1052, + 0, 0, 129, 130, 131, 0, 132, 133, 134, 135, + 136, 137, 138, 139, 1053, 141, 1054, 1055, 0, 144, + 145, 146, 147, 148, 149, 1056, 789, 150, 151, 152, + 153, 1057, 1058, 156, 0, 157, 158, 159, 160, 790, + 0, 791, 0, 1059, 164, 165, 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, - 0, 0, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, + 0, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 1060, 191, 192, 1061, 194, 1062, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, - 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, + 204, 205, 0, 0, 206, 207, 1063, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, - 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, - 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, - 235, 0, 23, 0, 238, 239, 528, 0, 242, 0, - 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, - 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, - 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, - 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, - 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, - 287, 288, 0, 0, 289, 0, 291, 0, 0, 293, - 294, 295, 296, 297, 298, 299, 300, 529, 302, 303, + 219, 220, 1064, 222, 223, 224, 225, 226, 227, 792, + 1065, 229, 0, 230, 231, 1066, 233, 0, 234, 0, + 235, 236, 0, 237, 238, 239, 240, 241, 242, 0, + 243, 0, 1067, 1068, 246, 247, 0, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 0, + 260, 261, 262, 263, 264, 265, 266, 0, 267, 268, + 269, 270, 271, 272, 273, 274, 1069, 1070, 0, 1071, + 0, 278, 279, 280, 281, 282, 283, 284, 285, 286, + 287, 288, 0, 0, 289, 290, 291, 292, 0, 293, + 294, 295, 296, 297, 298, 299, 300, 1072, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 321, 322, 0, - 324, 325, 326, 327, 328, 0, 329, 330, 0, 332, - 0, 333, 334, 335, 336, 337, 338, 0, 339, 340, - 0, 0, 341, 342, 343, 0, 0, 344, 345, 346, - 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, 361, 26, 27, 28, 0, 362, - 363, 364, 0, 366, 367, 368, 369, 370, 371, 0, + 314, 315, 316, 317, 318, 319, 320, 321, 1073, 323, + 1074, 325, 326, 327, 328, 1075, 329, 330, 331, 332, + 1076, 794, 334, 1077, 336, 337, 338, 0, 339, 340, + 0, 0, 1078, 342, 343, 0, 0, 344, 345, 346, + 347, 348, 349, 796, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, + 363, 797, 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, - 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, + 381, 382, 1079, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, - 400, 0, 401, 402, 0, 404, 405, 406, 407, 408, + 400, 0, 401, 402, 403, 404, 405, 406, 1080, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, - 419, 420, 33, 0, 421, 422, 423, 424, 425, 426, - 427, 428, 429, 0, 0, 431, 432, 433, 434, 0, + 419, 420, 0, 0, 421, 422, 423, 424, 425, 426, + 427, 428, 429, 0, 430, 431, 432, 1081, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, - 445, 446, 530, 448, 449, 0, 0, 450, 451, 38, - 452, 0, 454, 455, 456, 457, 458, 0, 459, 460, - 461, 0, 0, 462, 463, 464, 465, 466, 0, 467, - 468, 469, 470, 471, 472, 473, 474, 0, 0, 475, - 476, 477, 40, 478, 479, 480, 481, 0, 482, 483, - 484, 485, 486, 803, 488, 0, 489, 0, 491, 492, - 493, 494, 495, 496, 497, 0, 0, 498, 0, 44, + 445, 446, 447, 448, 799, 0, 0, 450, 451, 0, + 452, 453, 454, 455, 456, 457, 458, 0, 459, 1082, + 1083, 0, 0, 462, 463, 800, 465, 801, 1084, 467, + 468, 802, 470, 471, 472, 473, 474, 0, 0, 475, + 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, + 484, 485, 486, 487, 1085, 0, 489, 490, 491, 492, + 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, - 519, 0, 527, 45, 553, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 46, 0, 0, - 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, - 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, - 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, - 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, - 154, 155, 156, 0, 157, 158, 159, 160, 161, 0, - 0, 0, 163, 164, 165, 166, 167, 168, 0, 170, - 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, - 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, - 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, - 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, - 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 0, - 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, - 0, 0, 0, 238, 239, 528, 0, 242, 0, 243, - 0, 244, 245, 246, 247, 0, 248, 249, 250, 251, - 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, - 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, - 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, - 278, 0, 0, 281, 0, 283, 284, 285, 286, 287, - 288, 0, 0, 289, 0, 291, 0, 0, 293, 294, - 295, 296, 297, 298, 299, 300, 529, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 0, 324, - 325, 326, 327, 328, 0, 329, 330, 0, 332, 0, - 333, 334, 335, 336, 337, 338, 0, 339, 340, 0, - 0, 341, 342, 343, 0, 0, 344, 345, 346, 0, - 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, - 364, 0, 366, 367, 368, 369, 370, 371, 0, 372, - 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, - 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, - 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, - 0, 401, 402, 0, 404, 405, 406, 407, 408, 409, - 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, - 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, - 428, 429, 0, 0, 431, 432, 433, 434, 0, 435, - 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, - 446, 530, 448, 449, 0, 0, 450, 451, 0, 452, - 0, 454, 455, 456, 457, 458, 0, 459, 460, 461, - 0, 0, 462, 463, 464, 465, 466, 0, 467, 468, - 469, 470, 471, 472, 473, 474, 0, 0, 475, 476, - 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, - 485, 486, 487, 488, 0, 489, 0, 491, 492, 493, - 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, - 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, - 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, - 527, 0, 553, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 988, 0, 0, 118, - 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, - 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, - 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, - 148, 149, 0, 0, 150, 151, 152, 153, 154, 155, - 156, 0, 157, 158, 159, 160, 161, 0, 0, 0, - 163, 164, 165, 166, 167, 168, 0, 170, 171, 172, - 0, 173, 174, 175, 176, 177, 178, 0, 0, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, - 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, - 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, - 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, - 0, 214, 215, 216, 0, 217, 218, 219, 220, 221, - 222, 223, 224, 225, 226, 227, 228, 0, 229, 0, - 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, - 0, 238, 239, 528, 0, 242, 0, 243, 0, 244, - 245, 246, 247, 0, 248, 249, 250, 251, 252, 253, - 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, - 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, - 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, - 0, 281, 0, 283, 284, 285, 286, 287, 288, 0, - 0, 289, 0, 291, 0, 0, 293, 294, 295, 296, - 297, 298, 299, 300, 529, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 0, 324, 325, 326, - 327, 328, 0, 329, 330, 0, 332, 0, 333, 334, - 335, 336, 337, 338, 0, 339, 340, 0, 0, 341, - 342, 343, 0, 0, 344, 345, 346, 0, 348, 0, - 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, 361, 0, 0, 0, 0, 362, 363, 364, 0, - 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, - 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, - 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, - 402, 0, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, - 0, 421, 422, 423, 424, 425, 426, 427, 428, 429, - 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, - 438, 439, 440, 441, 442, 443, 444, 445, 446, 530, - 448, 449, 0, 0, 450, 451, 0, 452, 0, 454, - 455, 456, 457, 458, 0, 459, 460, 461, 0, 0, - 462, 463, 464, 465, 466, 0, 467, 468, 469, 470, - 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, - 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, - 487, 488, 0, 489, 0, 491, 492, 493, 494, 495, - 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, - 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, - 512, 513, 514, 515, 516, 517, 518, 519, 527, 0, - 553, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1468, 0, 0, 118, 119, 120, - 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, - 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, - 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, - 0, 0, 150, 151, 152, 153, 154, 155, 156, 0, - 157, 158, 159, 160, 161, 0, 0, 0, 163, 164, - 165, 166, 167, 168, 0, 170, 171, 172, 0, 173, - 174, 175, 176, 177, 178, 0, 0, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, - 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, - 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, - 215, 216, 0, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, - 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, - 239, 528, 0, 242, 0, 243, 0, 244, 245, 246, - 247, 0, 248, 249, 250, 251, 252, 253, 254, 0, - 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, - 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, - 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, - 0, 283, 284, 285, 286, 287, 288, 0, 0, 289, - 0, 291, 0, 0, 293, 294, 295, 296, 297, 298, - 299, 300, 529, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 322, 0, 324, 325, 326, 327, 328, - 0, 329, 330, 0, 332, 0, 333, 334, 335, 336, - 337, 338, 0, 339, 340, 0, 0, 341, 342, 343, - 0, 0, 344, 345, 346, 0, 348, 0, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, - 0, 0, 0, 0, 362, 363, 364, 0, 366, 367, - 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, - 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, - 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 397, 398, 399, 400, 0, 401, 402, 0, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, - 422, 423, 424, 425, 426, 427, 428, 429, 0, 0, - 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, - 440, 441, 442, 443, 444, 445, 446, 530, 448, 449, - 0, 0, 450, 451, 0, 452, 0, 454, 455, 456, - 457, 458, 0, 459, 460, 461, 0, 0, 462, 463, - 464, 465, 466, 0, 467, 468, 469, 470, 471, 472, - 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, - 480, 481, 0, 482, 483, 484, 485, 486, 487, 488, - 0, 489, 0, 491, 492, 493, 494, 495, 496, 497, - 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, - 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, - 514, 515, 516, 517, 518, 519, 527, 0, 553, 0, + 519, 1086, 0, 0, 0, 0, 0, 0, 1087, 3089, + 1089, 0, 0, 0, 0, 1090, 0, 1091, 0, 0, + 0, 0, 1092, 1093, 0, 1094, 1095, 117, 1046, 819, + 1047, 1048, 1049, 1050, 1051, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, + 0, 0, 0, 1052, 0, 0, 129, 130, 131, 0, + 132, 133, 134, 135, 136, 137, 138, 139, 1053, 141, + 1054, 1055, 0, 144, 145, 146, 147, 148, 149, 1056, + 789, 150, 151, 152, 153, 1057, 1058, 156, 0, 157, + 158, 159, 160, 790, 0, 791, 0, 1059, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 179, 180, 3036, 182, 183, + 184, 185, 186, 187, 188, 189, 1060, 191, 192, 1061, + 194, 1062, 195, 0, 196, 197, 198, 199, 200, 201, + 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, + 1063, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 1064, 222, 223, 224, + 225, 226, 227, 792, 1065, 229, 0, 230, 231, 1066, + 233, 0, 234, 0, 235, 236, 0, 237, 238, 239, + 240, 241, 242, 0, 243, 0, 3037, 1068, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, + 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 1069, 1070, 0, 1071, 0, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 290, + 291, 292, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 1072, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 1073, 323, 1074, 325, 326, 327, 328, 1075, + 329, 330, 331, 332, 1076, 794, 334, 1077, 336, 337, + 338, 0, 339, 340, 0, 0, 1078, 342, 343, 0, + 0, 344, 345, 346, 347, 348, 349, 796, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, + 0, 0, 0, 362, 363, 797, 365, 366, 367, 368, + 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, + 0, 378, 379, 380, 381, 382, 1079, 384, 385, 386, + 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 0, 401, 402, 403, 404, + 405, 3038, 1080, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 0, 430, 431, + 432, 1081, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 447, 448, 799, 0, + 0, 450, 451, 0, 452, 453, 454, 455, 456, 457, + 458, 0, 459, 1082, 1083, 0, 0, 462, 463, 800, + 465, 801, 1084, 467, 468, 802, 470, 471, 472, 473, + 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 487, 1085, 0, + 489, 490, 491, 492, 493, 494, 495, 496, 497, 0, + 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 1086, 0, 0, 0, 0, + 0, 0, 1087, 1088, 1089, 0, 0, 0, 0, 1090, + 0, 3039, 0, 0, 0, 0, 1092, 1093, 0, 1094, + 1095, 117, 1046, 819, 1047, 1048, 1049, 1050, 1051, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, + 127, 128, 0, 0, 0, 0, 0, 1052, 0, 0, + 129, 130, 131, 0, 132, 133, 134, 135, 136, 137, + 138, 3497, 1053, 141, 1054, 1055, 0, 144, 145, 146, + 147, 148, 149, 1056, 789, 150, 151, 152, 153, 1057, + 1058, 156, 0, 157, 158, 159, 160, 790, 0, 791, + 0, 1059, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 0, 173, 174, 175, 176, 177, 178, 0, 179, + 180, 181, 3498, 183, 184, 185, 186, 187, 188, 189, + 1060, 191, 192, 1061, 194, 1062, 195, 0, 196, 197, + 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, + 0, 0, 206, 207, 1063, 209, 210, 0, 211, 212, + 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, + 1064, 222, 223, 224, 225, 226, 227, 792, 1065, 229, + 0, 230, 231, 1066, 233, 0, 234, 0, 235, 236, + 0, 237, 238, 239, 240, 241, 242, 0, 243, 0, + 1067, 1068, 246, 247, 0, 248, 249, 250, 251, 252, + 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, + 262, 263, 264, 265, 266, 0, 267, 268, 269, 270, + 271, 272, 273, 274, 1069, 1070, 0, 1071, 0, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 0, 0, 289, 290, 291, 292, 0, 293, 294, 295, + 296, 297, 298, 299, 300, 1072, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 1073, 323, 1074, 325, + 326, 327, 328, 1075, 329, 330, 331, 332, 1076, 794, + 334, 1077, 336, 337, 338, 0, 339, 340, 0, 0, + 1078, 342, 343, 0, 0, 344, 345, 346, 347, 348, + 349, 796, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 360, 361, 0, 0, 0, 0, 362, 363, 797, + 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, + 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, + 1079, 384, 385, 386, 387, 0, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, + 401, 402, 403, 404, 405, 406, 1080, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, + 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, + 429, 0, 430, 431, 432, 1081, 434, 0, 435, 436, + 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, + 447, 448, 799, 0, 0, 450, 451, 0, 452, 453, + 454, 455, 456, 457, 458, 0, 459, 1082, 1083, 0, + 0, 462, 463, 800, 465, 801, 1084, 467, 468, 802, + 470, 471, 3499, 473, 474, 0, 0, 475, 476, 477, + 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, + 486, 487, 1085, 0, 489, 490, 491, 492, 493, 494, + 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, + 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, + 511, 512, 513, 514, 515, 516, 517, 518, 519, 1086, + 0, 0, 0, 0, 0, 0, 1087, 1088, 1089, 0, + 0, 0, 0, 1090, 0, 1091, 0, 0, 0, 0, + 1092, 1093, 0, 1094, 1095, 117, 1046, 819, 1047, 1048, + 1049, 1050, 1051, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, + 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, + 0, 1052, 0, 0, 129, 130, 131, 0, 132, 133, + 134, 135, 136, 137, 138, 139, 1053, 141, 1054, 1055, + 0, 144, 145, 146, 147, 148, 149, 1056, 789, 150, + 151, 152, 153, 1057, 1058, 156, 0, 157, 158, 159, + 160, 790, 0, 791, 0, 1059, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 0, 173, 174, 175, 176, + 177, 178, 0, 179, 180, 181, 3498, 183, 184, 185, + 186, 187, 188, 189, 1060, 191, 192, 1061, 194, 1062, + 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, + 202, 203, 204, 205, 0, 0, 206, 207, 1063, 209, + 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, + 217, 218, 219, 220, 1064, 222, 223, 224, 225, 226, + 227, 792, 1065, 229, 0, 230, 231, 1066, 233, 0, + 234, 0, 235, 236, 0, 237, 238, 239, 240, 241, + 242, 0, 243, 0, 1067, 1068, 246, 247, 0, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, + 267, 268, 269, 270, 271, 272, 273, 274, 1069, 1070, + 0, 1071, 0, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 0, 0, 289, 290, 291, 292, + 0, 293, 294, 295, 296, 297, 298, 299, 300, 1072, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 1073, 323, 1074, 325, 326, 327, 328, 1075, 329, 330, + 331, 332, 1076, 794, 334, 1077, 336, 337, 338, 0, + 339, 340, 0, 0, 1078, 342, 343, 0, 0, 344, + 345, 346, 347, 348, 349, 796, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, + 0, 362, 363, 797, 365, 366, 367, 368, 369, 370, + 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, + 379, 380, 381, 382, 1079, 384, 385, 386, 387, 0, + 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, + 398, 399, 400, 0, 401, 402, 403, 404, 405, 406, + 1080, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, + 425, 426, 427, 428, 429, 0, 430, 431, 432, 1081, + 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, + 443, 444, 445, 446, 447, 448, 799, 0, 0, 450, + 451, 0, 452, 453, 454, 455, 456, 457, 458, 0, + 459, 1082, 1083, 0, 0, 462, 463, 800, 465, 801, + 1084, 467, 468, 802, 470, 471, 3499, 473, 474, 0, + 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, + 482, 483, 484, 485, 486, 487, 1085, 0, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, + 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, + 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, + 517, 518, 519, 1086, 0, 0, 0, 0, 0, 0, + 1087, 1088, 1089, 0, 0, 0, 0, 1090, 0, 1091, + 0, 0, 0, 0, 1092, 1093, 0, 1094, 1095, 117, + 1046, 819, 1047, 1048, 1049, 1050, 1051, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, + 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, + 0, 0, 0, 0, 0, 1052, 0, 0, 129, 130, + 131, 0, 132, 133, 134, 135, 136, 137, 138, 139, + 1053, 141, 1054, 1055, 0, 144, 145, 146, 147, 148, + 149, 1056, 789, 150, 151, 152, 153, 1057, 1058, 156, + 0, 157, 158, 159, 160, 790, 0, 791, 0, 163, + 164, 165, 166, 167, 168, 169, 170, 171, 172, 0, + 173, 174, 175, 176, 177, 178, 0, 179, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 1060, 191, + 192, 1061, 194, 0, 195, 0, 196, 197, 198, 199, + 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, + 206, 207, 1063, 209, 210, 0, 211, 212, 213, 0, + 214, 215, 216, 0, 217, 218, 219, 220, 1064, 222, + 223, 224, 225, 226, 227, 792, 1065, 229, 0, 230, + 231, 1066, 233, 0, 234, 0, 235, 236, 0, 237, + 238, 239, 240, 241, 242, 0, 243, 0, 1067, 1068, + 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 0, 260, 261, 262, 263, + 264, 265, 266, 0, 267, 268, 269, 270, 271, 272, + 273, 274, 1069, 1070, 0, 1071, 0, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 0, 0, + 289, 290, 291, 292, 0, 293, 294, 295, 296, 297, + 298, 299, 300, 1072, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 1073, 323, 1074, 325, 326, 327, + 328, 0, 329, 330, 331, 332, 1076, 794, 334, 1077, + 336, 337, 338, 0, 339, 340, 0, 0, 1078, 342, + 343, 0, 0, 344, 345, 346, 347, 348, 349, 796, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + 361, 0, 0, 0, 0, 362, 363, 797, 365, 366, + 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, + 376, 377, 0, 378, 379, 380, 381, 382, 1079, 384, + 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, + 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, + 403, 404, 405, 406, 1080, 408, 409, 410, 411, 412, + 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, + 421, 422, 423, 424, 425, 426, 427, 428, 429, 0, + 430, 431, 432, 1081, 434, 0, 435, 436, 437, 438, + 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, + 799, 0, 0, 450, 451, 0, 452, 453, 454, 455, + 456, 457, 458, 0, 459, 1082, 1083, 0, 0, 462, + 463, 800, 465, 801, 1084, 467, 468, 802, 470, 471, + 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, + 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, + 1085, 0, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, + 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, + 513, 514, 515, 516, 517, 518, 519, 0, 0, 0, + 0, 0, 0, 0, 1421, 1422, 0, 0, 0, 0, + 0, 1090, 0, 1091, 0, 0, 0, 0, 1092, 1093, + 0, 1094, 1095, 117, 1046, 819, 1047, 1048, 1049, 1050, + 1051, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, + 0, 126, 127, 128, 0, 0, 0, 0, 0, 1052, + 0, 0, 129, 130, 131, 0, 132, 133, 134, 135, + 136, 137, 138, -2061, 1053, 141, 1054, 1055, 0, 144, + 145, 146, 147, 148, 149, 1056, 789, 150, 151, 152, + 153, 1057, 1058, 156, 0, 157, 158, 159, 160, 790, + 0, 791, 0, 1059, 164, 165, 166, 167, 168, 169, + 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, + 0, 179, 180, 181, 3498, 183, 184, 185, 186, 187, + 188, 189, 1060, 191, 192, 1061, 194, 1062, 195, 0, + 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, + 204, 205, 0, 0, 206, 207, 1063, 209, 210, 0, + 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, + 219, 220, 1064, 222, 223, 224, 225, 226, 227, 792, + 1065, 229, 0, 230, 231, 1066, 233, 0, 234, 0, + 235, 236, 0, 237, 238, 239, 240, -2061, 242, 0, + 243, 0, 1067, 1068, 246, 247, 0, 248, 249, 250, + 251, 252, 253, 254, -2061, 256, 257, 258, 259, 0, + 260, 261, 262, 263, 264, 265, 266, 0, 267, 268, + 269, 270, 271, 272, 273, 274, 1069, 1070, 0, 1071, + 0, 278, 0, 0, 281, 282, 283, 284, 285, 286, + 287, 288, 0, 0, 289, 290, 291, -2061, 0, 293, + 294, 295, 296, 297, 298, 299, 300, 1072, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 1073, 323, + 1074, 325, 326, 327, 328, 0, 329, 330, 0, 332, + 1076, 794, 334, 1077, 336, 337, 338, 0, 339, 340, + 0, 0, 1078, 342, 343, 0, 0, 344, 345, 346, + 347, 348, 349, 796, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, + 363, 797, 365, 366, 367, 368, 369, 370, 371, 0, + 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, + 381, 382, 1079, 384, 385, 386, 387, 0, 388, 389, + 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, + 400, 0, 401, 402, 403, 404, 405, 406, 1080, 408, + 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, + 419, 420, 0, 0, 421, 422, 423, 424, 425, 426, + 427, 428, 429, 0, -2061, 431, 432, 1081, 434, 0, + 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, + 445, 446, 447, 448, 799, 0, 0, 450, 451, 0, + 452, 453, 454, 455, 456, 457, 458, 0, 459, 1082, + 1083, 0, 0, 462, 463, 800, 465, 801, 1084, 467, + 468, 802, 470, 471, 3499, 473, 474, 0, 0, 475, + 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, + 484, 485, 486, 487, 1085, 0, 489, 490, 491, 492, + 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, + 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, + 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, + 519, -2061, 0, 0, 0, 0, 0, 0, 1087, 1088, + 1089, 0, 0, 0, 0, 1090, 0, 1091, 0, 0, + 0, 0, 1092, 1093, 0, 1094, 1095, 117, 1046, 819, + 1047, 1048, 0, 1050, 1051, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, + 0, 0, 0, 1052, 0, 0, 129, 130, 131, 0, + 132, 133, 134, 135, 136, 137, 138, 139, 1053, 141, + 1054, 1055, 0, 144, 145, 146, 147, 148, 149, 1056, + 789, 150, 151, 152, 153, 1057, 1058, 156, 0, 157, + 158, 159, 160, 790, 0, 791, 0, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 1060, 191, 192, 1061, + 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, + 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, + 1063, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 1064, 222, 223, 224, + 225, 226, 227, 792, 1065, 229, 0, 230, 231, 1066, + 233, 0, 234, 0, 235, 236, 0, 237, 238, 239, + 240, 241, 242, 0, 243, 0, 1067, 1068, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, + 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 1069, 1070, 0, 1071, 0, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 290, + 291, 292, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 1072, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 1073, 323, 1074, 325, 326, 327, 328, 0, + 329, 330, 331, 332, 1076, 794, 334, 1077, 336, 337, + 338, 0, 339, 340, 0, 0, 341, 342, 343, 0, + 0, 344, 345, 346, 347, 348, 349, 796, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, + 0, 0, 0, 362, 363, 797, 365, 366, 367, 368, + 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, + 0, 378, 379, 380, 381, 382, 1079, 384, 385, 386, + 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 0, 401, 402, 403, 404, + 405, 406, 2188, 2189, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 0, 430, 431, + 432, 1081, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 447, 448, 799, 0, + 0, 450, 451, 0, 452, 453, 454, 455, 456, 457, + 458, 0, 459, 1082, 1083, 0, 0, 462, 463, 800, + 465, 801, 1084, 467, 468, 802, 470, 471, 472, 473, + 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 487, 1085, 0, + 489, 490, 491, 492, 493, 494, 495, 496, 497, 0, + 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 0, 0, 0, 0, 0, + 0, 0, 2190, 2191, 0, 0, 0, 0, 0, 1090, + 0, 1091, 0, 0, 0, 0, 1092, 1093, 0, 1094, + 1095, 117, 1046, 819, 1047, 1048, 1049, 1050, 1051, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, + 127, 128, 0, 0, 0, 0, 0, 1052, 0, 0, + 129, 130, 131, 0, 132, 133, 134, 135, 136, 137, + 138, 139, 1053, 141, 1054, 1055, 0, 144, 145, 146, + 147, 148, 149, 1056, 789, 150, 151, 152, 153, 1057, + 1058, 156, 0, 157, 158, 159, 160, 790, 0, 791, + 0, 163, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 0, 173, 174, 175, 176, 177, 178, 0, 179, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 1060, 191, 192, 1061, 194, 0, 195, 0, 196, 197, + 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, + 0, 0, 206, 207, 1063, 209, 210, 0, 211, 212, + 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, + 1064, 222, 223, 224, 225, 226, 227, 792, 1065, 229, + 0, 230, 231, 1066, 233, 0, 234, 0, 235, 236, + 0, 237, 238, 239, 240, 241, 242, 0, 243, 0, + 1067, 1068, 246, 247, 0, 248, 249, 250, 251, 252, + 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, + 262, 263, 264, 265, 266, 0, 267, 268, 269, 270, + 271, 272, 273, 274, 1069, 1070, 0, 1071, 0, 278, + 0, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 0, 0, 289, 290, 291, 292, 0, 293, 294, 295, + 296, 297, 298, 299, 300, 1072, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 1073, 323, 1074, 325, + 326, 327, 328, 0, 329, 330, 331, 332, 1076, 794, + 334, 1077, 336, 337, 338, 0, 339, 340, 0, 0, + 1078, 342, 343, 0, 0, 344, 345, 346, 347, 348, + 349, 796, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 360, 361, 0, 0, 0, 0, 362, 363, 797, + 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, + 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, + 1079, 384, 385, 386, 387, 0, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, + 401, 402, 403, 404, 405, 406, 1080, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, + 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, + 429, 0, 430, 431, 432, 1081, 434, 0, 435, 436, + 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, + 447, 448, 799, 0, 0, 450, 451, 0, 452, 453, + 454, 455, 456, 457, 458, 0, 459, 1082, 1083, 0, + 0, 462, 463, 800, 465, 801, 1084, 467, 468, 802, + 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, + 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, + 486, 487, 1085, 0, 489, 490, 491, 492, 493, 494, + 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, + 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, + 511, 512, 513, 514, 515, 516, 517, 518, 519, 0, + 0, 0, 0, 0, 0, 0, 1421, 1422, 0, 0, + 0, 0, 0, 1090, 0, 1091, 0, 0, 0, 0, + 1092, 1093, 0, 1094, 1095, 117, 1046, 819, 1047, 1048, + 0, 1050, 1051, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, + 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, + 0, 1052, 0, 0, 129, 130, 131, 0, 132, 133, + 134, 135, 136, 137, 138, 139, 1053, 141, 1054, 1055, + 0, 144, 145, 146, 147, 148, 149, 1056, 789, 150, + 151, 152, 153, 1057, 1058, 156, 0, 157, 158, 159, + 160, 790, 0, 791, 0, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 0, 173, 174, 175, 176, + 177, 178, 0, 179, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 1060, 191, 192, 1061, 194, 0, + 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, + 202, 203, 204, 205, 0, 0, 206, 207, 1063, 209, + 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, + 217, 218, 219, 220, 1064, 222, 223, 224, 225, 226, + 227, 792, 1065, 229, 0, 230, 231, 1066, 233, 0, + 234, 0, 235, 236, 0, 237, 238, 239, 240, 241, + 242, 0, 243, 3056, 1067, 1068, 246, 247, 0, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, -723, 260, 261, 262, 263, 264, 265, 266, 0, + 267, 268, 269, 270, 271, 272, 273, 274, 1069, 1070, + 0, 1071, 0, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 0, 0, 289, 290, 291, 292, + 0, 293, 294, 295, 296, 297, 298, 299, 300, 1072, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 1073, 323, 1074, 325, 326, 327, 328, 0, 329, 330, + 331, 332, 1076, 794, 334, 1077, 336, 337, 338, 0, + 339, 340, 0, 0, 341, 342, 343, 0, 0, 344, + 345, 346, 347, 348, 349, 796, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, + 0, 362, 363, 797, 365, 366, 367, 368, 369, 370, + 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, + 379, 380, 381, 382, 1079, 384, 385, 386, 387, 0, + 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, + 398, 399, 400, 0, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, + 425, 426, 427, 428, 429, 0, 430, 431, 432, 1081, + 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, + 443, 444, 445, 446, 447, 448, 799, 0, 0, 450, + 451, 0, 452, 453, 454, 455, 456, 457, 458, 0, + 459, 1082, 1083, 0, 0, 462, 463, 800, 465, 801, + 1084, 467, 468, 802, 470, 471, 472, 473, 474, 0, + 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, + 482, 483, 484, 485, 486, 487, 1085, 0, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, + 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, + 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, + 517, 518, 519, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1090, 0, 2749, + 0, 0, 0, 0, 1092, 1093, 0, 1094, 1095, 117, + 1046, 819, 1047, 1048, 0, 1050, 1051, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, + 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, + 0, 0, 0, 0, 0, 1052, 0, 0, 129, 130, + 131, 0, 132, 133, 134, 135, 136, 137, 138, 139, + 1053, 141, 1054, 1055, 0, 144, 145, 146, 147, 148, + 149, 1056, 789, 150, 151, 152, 153, 1057, 1058, 156, + 0, 157, 158, 159, 160, 790, 0, 791, 0, 163, + 164, 165, 166, 167, 168, 169, 170, 171, 172, 0, + 173, 174, 175, 176, 177, 178, 0, 179, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 1060, 191, + 192, 1061, 194, 0, 195, 0, 196, 197, 198, 199, + 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, + 206, 207, 1063, 209, 210, 0, 211, 212, 213, 0, + 214, 215, 216, 0, 217, 218, 219, 220, 1064, 222, + 223, 224, 225, 226, 227, 792, 1065, 229, 0, 230, + 231, 1066, 233, 0, 234, 0, 235, 236, 0, 237, + 238, 239, 240, 241, 242, 0, 243, 0, 1067, 1068, + 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 0, 260, 261, 262, 263, + 264, 265, 266, 0, 267, 268, 269, 270, 271, 272, + 273, 274, 1069, 1070, 0, 1071, 0, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 0, 0, + 289, 290, 291, 292, 0, 293, 294, 295, 296, 297, + 298, 299, 300, 1072, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 1073, 323, 1074, 325, 326, 327, + 328, 0, 329, 330, 331, 332, 1076, 794, 334, 1077, + 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, + 343, 0, 0, 344, 345, 346, 347, 348, 349, 796, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + 361, 0, 0, 0, 0, 362, 363, 797, 365, 366, + 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, + 376, 377, 0, 378, 379, 380, 381, 382, 1079, 384, + 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, + 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, + 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, + 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, + 421, 422, 423, 424, 425, 426, 427, 428, 429, 0, + 430, 431, 432, 1081, 434, 0, 435, 436, 437, 438, + 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, + 799, 0, 0, 450, 451, 0, 452, 453, 454, 455, + 456, 457, 458, 0, 459, 1082, 1083, 0, 0, 462, + 463, 800, 465, 801, 1084, 467, 468, 802, 470, 471, + 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, + 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, + 1085, 0, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, + 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, + 513, 514, 515, 516, 517, 518, 519, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 2209, 0, 0, 118, 119, 120, 121, 122, + 0, 1090, 0, 2749, 0, 0, 0, 0, 1092, 1093, + 0, 1094, 1095, 117, 1046, 819, 1047, 1048, 0, 1050, + 1051, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, + 0, 126, 127, 128, 0, 0, 0, 0, 0, 1052, + 0, 0, 129, 130, 131, 0, 132, 133, 134, 135, + 136, 137, 138, 139, 1053, 141, 1054, 1055, 0, 144, + 145, 146, 147, 148, 149, 1056, 789, 150, 151, 152, + 153, 1057, 1058, 156, 0, 157, 158, 159, 160, 790, + 0, 791, 0, 163, 164, 165, 166, 167, 168, 169, + 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, + 0, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 1060, 191, 192, 1061, 194, 0, 195, 0, + 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, + 204, 205, 0, 0, 206, 207, 1063, 209, 210, 0, + 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, + 219, 220, 1064, 222, 223, 224, 225, 226, 227, 792, + 1065, 229, 0, 230, 231, 1066, 233, 0, 234, 0, + 235, 236, 0, 237, 238, 239, 240, 241, 242, 0, + 243, 0, 1067, 1068, 246, 247, 0, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 0, + 260, 261, 262, 263, 264, 265, 266, 0, 267, 268, + 269, 270, 271, 272, 273, 274, 1069, 1070, 0, 1071, + 0, 278, 279, 280, 281, 282, 283, 284, 285, 286, + 287, 288, 0, 0, 289, 290, 291, 292, 0, 293, + 294, 295, 296, 297, 298, 299, 300, 1072, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 1073, 323, + 1074, 325, 326, 327, 328, 0, 329, 330, 331, 332, + 1076, 794, 334, 1077, 336, 337, 338, 0, 339, 340, + 0, 0, 341, 342, 343, 0, 0, 344, 345, 346, + 347, 348, 349, 796, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, + 363, 797, 365, 366, 367, 368, 369, 370, 371, 0, + 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, + 381, 382, 1079, 384, 385, 386, 387, 0, 388, 389, + 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, + 400, 0, 401, 402, 403, 404, 405, 406, 1080, 408, + 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, + 419, 420, 0, 0, 421, 422, 423, 424, 425, 426, + 427, 428, 429, 0, 430, 431, 432, 1081, 434, 0, + 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, + 445, 446, 447, 448, 799, 0, 0, 450, 451, 0, + 452, 453, 454, 455, 456, 457, 458, 0, 459, 1082, + 1083, 0, 0, 462, 463, 800, 465, 801, 1084, 467, + 468, 802, 470, 471, 472, 473, 474, 0, 0, 475, + 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, + 484, 485, 486, 487, 1085, 0, 489, 490, 491, 492, + 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, + 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, + 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, + 519, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1090, 0, 1091, 0, 0, + 0, 0, 1092, 1093, 0, 1094, 1095, 117, 1046, 819, + 1047, 1048, 1049, 1050, 1051, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, + 0, 0, 0, 1052, 0, 0, 129, 130, 131, 0, + 132, 133, 134, 135, 136, 137, 138, 0, 1053, 141, + 1054, 1055, 0, 144, 145, 146, 147, 148, 149, 1056, + 789, 150, 151, 152, 153, 1057, 1058, 156, 0, 157, + 158, 159, 160, 790, 0, 791, 0, 1059, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 1060, 191, 192, 1061, + 194, 1062, 195, 0, 196, 197, 198, 199, 200, 201, + 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, + 1063, 209, 210, 0, 211, 212, 213, 0, 214, 0, + 216, 0, 217, 218, 219, 220, 1064, 222, 223, 224, + 225, 226, 227, 792, 1065, 229, 0, 230, 231, 1066, + 233, 0, 234, 0, 235, 236, 0, 237, 238, 239, + 240, 0, 242, 0, 243, 0, 1067, 1068, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 0, 256, + 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, + 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 1069, 1070, 0, 1071, 0, 278, 0, 0, 281, 282, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 290, + 291, 0, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 1072, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 1073, 323, 1074, 325, 326, 327, 328, 0, + 329, 330, 0, 332, 1076, 794, 334, 1077, 336, 337, + 338, 0, 339, 340, 0, 0, 1078, 342, 343, 0, + 0, 344, 345, 346, 347, 348, 349, 796, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, + 0, 0, 0, 362, 363, 797, 365, 366, 367, 368, + 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, + 0, 378, 379, 380, 381, 382, 1079, 384, 385, 386, + 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 0, 401, 402, 403, 404, + 405, 406, 1080, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 0, 0, 431, + 432, 1081, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 447, 448, 799, 0, + 0, 450, 451, 0, 452, 453, 454, 455, 456, 457, + 458, 0, 459, 1082, 1083, 0, 0, 462, 463, 800, + 465, 801, 1084, 467, 468, 802, 470, 471, 472, 473, + 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 487, 1085, 0, + 489, 490, 491, 492, 493, 494, 495, 496, 497, 0, + 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 0, 0, 0, 0, 0, + 0, 0, 1087, 1088, 1089, 0, 970, 1350, 819, 1090, + 0, 1091, 1050, 0, 0, 0, 1092, 1093, 0, 1094, + 1095, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, - 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, - 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, - 150, 151, 152, 153, 154, 155, 156, 0, 157, 158, - 159, 160, 161, 0, 0, 0, 163, 164, 165, 166, - 167, 168, 0, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 0, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 564, 0, 0, 0, 0, 569, 130, 131, 0, 132, + 133, 134, 571, 136, 137, 138, 572, 573, 574, 575, + 576, 0, 144, 145, 146, 147, 148, 149, 0, 0, + 150, 151, 152, 153, 580, 581, 156, 0, 157, 158, + 159, 160, 583, 0, 585, 0, 587, 164, 165, 166, + 167, 168, 588, 170, 171, 172, 0, 173, 174, 175, + 176, 177, 178, 0, 591, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 189, 593, 191, 192, 594, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, - 0, 234, 0, 235, 0, 0, 0, 238, 239, 528, - 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 0, 256, 257, + 0, 217, 218, 219, 220, 604, 222, 223, 224, 225, + 226, 227, 605, 1351, 229, 0, 230, 231, 608, 233, + 0, 234, 0, 235, 611, 0, 613, 238, 239, 614, + 615, 242, 0, 243, 0, 618, 619, 246, 247, 0, + 248, 249, 250, 251, 252, 253, 254, 621, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, - 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 0, 291, - 0, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 529, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 0, 267, 624, 625, 270, 271, 272, 273, 274, 626, + 627, 0, 629, 0, 278, 631, 632, 281, 633, 283, + 284, 285, 286, 287, 288, 0, 0, 289, 636, 291, + 637, 0, 293, 294, 295, 296, 297, 298, 299, 300, + 639, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 0, 324, 325, 326, 327, 328, 0, 329, - 330, 0, 332, 0, 333, 334, 335, 336, 337, 338, - 0, 339, 340, 0, 0, 341, 342, 343, 0, 0, - 344, 345, 346, 0, 348, 0, 350, 351, 352, 353, + 321, 640, 641, 642, 325, 326, 327, 643, 0, 329, + 330, 645, 332, 0, 647, 334, 648, 336, 337, 338, + 0, 339, 340, 1352, 0, 341, 342, 343, 0, 0, + 344, 345, 654, 655, 348, 656, 657, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 364, 0, 366, 367, 368, 369, + 0, 0, 362, 363, 662, 663, 366, 367, 664, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, + 378, 379, 380, 381, 382, 667, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 0, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 0, 431, 432, - 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 530, 448, 449, 0, 0, - 450, 451, 0, 452, 0, 454, 455, 456, 457, 458, - 0, 459, 460, 461, 0, 0, 462, 463, 464, 465, - 466, 0, 467, 468, 469, 470, 471, 472, 473, 474, + 397, 398, 399, 400, 0, 401, 402, 670, 404, 405, + 406, 671, 408, 409, 410, 411, 412, 413, 414, 415, + 416, 417, 418, 419, 420, 0, 673, 421, 422, 423, + 424, 425, 426, 674, 428, 429, 0, 676, 431, 432, + 677, 434, 0, 435, 436, 437, 438, 439, 440, 441, + 442, 443, 444, 445, 446, 679, 448, 680, 0, 0, + 450, 451, 0, 452, 684, 454, 455, 456, 457, 458, + 0, 459, 686, 687, 0, 0, 462, 463, 690, 465, + 691, 1353, 467, 468, 693, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 488, 0, 489, - 0, 491, 492, 493, 494, 495, 496, 497, 0, 0, - 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 527, 0, 553, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 2445, 0, 0, 118, 119, 120, 121, 122, 123, 124, - 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, - 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, - 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, - 152, 153, 154, 155, 156, 0, 157, 158, 159, 160, - 161, 0, 0, 0, 163, 164, 165, 166, 167, 168, - 0, 170, 171, 172, 0, 173, 174, 175, 176, 177, - 178, 0, 0, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, - 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, - 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, - 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, - 0, 235, 0, 0, 0, 238, 239, 528, 0, 242, - 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, - 250, 251, 252, 253, 254, 0, 256, 257, 258, 259, - 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, - 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, - 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, - 286, 287, 288, 0, 0, 289, 0, 291, 0, 0, - 293, 294, 295, 296, 297, 298, 299, 300, 529, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 0, 324, 325, 326, 327, 328, 0, 329, 330, 0, - 332, 0, 333, 334, 335, 336, 337, 338, 0, 339, - 340, 0, 0, 341, 342, 343, 0, 0, 344, 345, - 346, 0, 348, 0, 350, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, - 362, 363, 364, 0, 366, 367, 368, 369, 370, 371, - 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, - 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, - 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, - 399, 400, 0, 401, 402, 0, 404, 405, 406, 407, - 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, - 426, 427, 428, 429, 0, 0, 431, 432, 433, 434, - 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, - 444, 445, 446, 530, 448, 449, 0, 0, 450, 451, - 0, 452, 0, 454, 455, 456, 457, 458, 0, 459, - 460, 461, 0, 0, 462, 463, 464, 465, 466, 0, - 467, 468, 469, 470, 471, 472, 473, 474, 0, 0, - 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, - 483, 484, 485, 486, 487, 488, 0, 489, 0, 491, - 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, - 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, - 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, - 518, 519, 527, 0, 553, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 2579, 0, - 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, - 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, - 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, - 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, - 154, 155, 156, 0, 157, 158, 159, 160, 161, 0, - 0, 0, 163, 164, 165, 166, 167, 168, 0, 170, - 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, - 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, - 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, - 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, - 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 0, - 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, - 0, 0, 0, 238, 239, 528, 0, 242, 0, 243, - 0, 244, 245, 246, 247, 0, 248, 249, 250, 251, - 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, - 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, - 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, - 278, 0, 0, 281, 0, 283, 284, 285, 286, 287, - 288, 0, 0, 289, 0, 291, 0, 0, 293, 294, - 295, 296, 297, 298, 299, 300, 529, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 0, 324, - 325, 326, 327, 328, 0, 329, 330, 0, 332, 0, - 333, 334, 335, 336, 337, 338, 0, 339, 340, 0, - 0, 341, 342, 343, 0, 0, 344, 345, 346, 0, - 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, - 364, 0, 366, 367, 368, 369, 370, 371, 0, 372, - 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, - 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, - 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, - 0, 401, 402, 0, 404, 405, 406, 407, 408, 409, - 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, - 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, - 428, 429, 0, 0, 431, 432, 433, 434, 0, 435, - 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, - 446, 530, 448, 449, 0, 0, 450, 451, 0, 452, - 0, 454, 455, 456, 457, 458, 0, 459, 460, 461, - 0, 0, 462, 463, 464, 465, 466, 0, 467, 468, - 469, 470, 471, 472, 473, 474, 0, 0, 475, 476, - 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, - 485, 486, 487, 488, 0, 489, 0, 491, 492, 493, - 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, - 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, - 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, - 527, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 3224, 0, 0, 118, - 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, - 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, - 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, - 148, 149, 0, 0, 150, 151, 152, 153, 154, 155, - 156, 0, 157, 158, 159, 160, 161, 0, 0, 0, - 163, 164, 165, 166, 167, 168, 0, 170, 171, 172, - 0, 173, 174, 175, 176, 177, 178, 0, 0, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, - 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, - 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, - 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, - 0, 214, 215, 216, 0, 217, 218, 219, 220, 221, - 222, 223, 224, 225, 226, 227, 228, 0, 229, 0, - 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, - 0, 238, 239, 528, 0, 242, 0, 243, 0, 244, - 245, 246, 247, 0, 248, 249, 250, 251, 252, 253, - 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, - 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, - 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, - 0, 281, 0, 283, 284, 285, 286, 287, 288, 0, - 0, 289, 0, 291, 0, 0, 293, 294, 295, 296, - 297, 298, 299, 300, 529, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 0, 324, 325, 326, - 327, 328, 0, 329, 330, 0, 332, 0, 333, 334, - 335, 336, 337, 338, 0, 339, 340, 0, 0, 341, - 342, 343, 0, 0, 344, 345, 346, 0, 348, 0, - 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, 361, 0, 0, 0, 0, 362, 363, 364, 0, - 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, - 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, - 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, - 402, 0, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, - 0, 421, 422, 423, 424, 425, 426, 427, 428, 429, - 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, - 438, 439, 440, 441, 442, 443, 444, 445, 446, 530, - 448, 449, 0, 0, 450, 451, 0, 452, 0, 454, - 455, 456, 457, 458, 0, 459, 460, 461, 0, 0, - 462, 463, 464, 465, 466, 0, 467, 468, 469, 470, - 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, - 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, - 487, 488, 0, 489, 0, 491, 492, 493, 494, 495, - 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, - 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, - 512, 513, 514, 515, 516, 517, 518, 519, 527, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 2062, 0, 0, 118, 119, 120, + 0, 482, 483, 484, 485, 486, 698, 699, 0, 489, + 701, 491, 492, 493, 494, 495, 496, 497, 0, 0, + 498, 0, 0, 499, 500, 501, 502, 503, 504, 706, + 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, + 516, 517, 518, 519, 0, 0, 0, 0, 527, 0, + 0, 1354, 1355, 2367, 0, 0, 0, 0, 2368, 0, + 2369, 0, 0, 0, 0, 0, 1093, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, + 0, 0, 0, 0, 0, 1005, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, 154, 155, 156, 0, @@ -6875,22 +7286,22 @@ static const yytype_int16 yytable[] = 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, - 215, 216, 0, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, - 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, + 215, 216, -530, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 0, 229, -530, 230, 231, + 232, 233, -530, 234, 0, 235, 0, 0, 0, 238, 239, 528, 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, - 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, + 274, 275, 276, -530, 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, 287, 288, 0, 0, 289, - 0, 291, 0, 0, 293, 294, 295, 296, 297, 298, + 0, 291, 0, -530, 293, 294, 295, 296, 297, 298, 299, 300, 529, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 0, 324, 325, 326, 327, 328, 0, 329, 330, 0, 332, 0, 333, 334, 335, 336, - 337, 338, 0, 339, 340, 0, 0, 341, 342, 343, - 0, 0, 344, 345, 346, 0, 348, 0, 350, 351, + 337, 338, -530, 339, 340, 0, 0, 341, 342, 343, + 0, -530, 344, 345, 346, 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, 364, 0, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, @@ -6905,14 +7316,14 @@ static const yytype_int16 yytable[] = 0, 0, 450, 451, 0, 452, 0, 454, 455, 456, 457, 458, 0, 459, 460, 461, 0, 0, 462, 463, 464, 465, 466, 0, 467, 468, 469, 470, 471, 472, - 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, + 473, 474, -530, 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, 488, 0, 489, 0, 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, - 514, 515, 516, 517, 518, 519, 527, 0, 0, 0, + 514, 515, 516, 517, 518, 519, 527, 0, 553, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 2165, 0, 0, 118, 119, 120, 121, 122, + 0, 0, 0, 1164, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, @@ -6960,1143 +7371,375 @@ static const yytype_int16 yytable[] = 0, 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 0, 2904, 1345, 819, 0, 0, - 2038, 1048, 0, 0, 0, 0, 0, 2039, 2040, 0, - 3085, 2041, 2042, 2043, 118, 119, 120, 121, 122, 123, - 124, 125, 560, 126, 127, 128, 561, 562, 563, 2905, - 565, 566, 567, 568, 2906, 130, 131, 570, 132, 133, - 134, 2907, 136, 137, 138, 0, 1481, 2908, 1483, 1484, - 577, 144, 145, 146, 147, 148, 149, 578, 579, 150, - 151, 152, 153, 1485, 1486, 156, 582, 157, 158, 159, - 160, 0, 584, 2909, 586, 2910, 164, 165, 166, 167, - 168, 2911, 170, 171, 172, 589, 173, 174, 175, 176, - 177, 178, 590, 2912, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 1491, 191, 192, 1492, 194, 595, - 195, 596, 196, 197, 198, 199, 200, 201, 597, 598, - 202, 203, 204, 205, 599, 600, 206, 207, 1061, 209, - 210, 601, 211, 212, 213, 602, 214, 215, 216, 603, - 217, 218, 219, 220, 0, 222, 223, 224, 225, 226, - 227, 0, 606, 229, 607, 230, 231, 1493, 233, 609, - 234, 610, 235, 2913, 612, 2914, 238, 239, 2915, 2916, - 242, 616, 243, 617, 0, 0, 246, 247, 620, 248, - 249, 250, 251, 252, 253, 254, 2917, 256, 257, 258, - 259, 622, 260, 261, 262, 263, 264, 265, 266, 623, - 267, 2918, 0, 270, 271, 272, 273, 274, 1499, 1500, - 628, 1501, 630, 278, 2919, 2920, 281, 2921, 283, 284, - 285, 286, 287, 288, 634, 635, 289, 2922, 291, 2923, - 638, 293, 294, 295, 296, 297, 298, 299, 300, 2924, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, - 1508, 2925, 1510, 325, 326, 327, 2926, 644, 329, 330, - 2927, 332, 646, 0, 334, 1512, 336, 337, 338, 649, - 339, 340, 650, 651, 2928, 342, 343, 652, 653, 344, - 345, 0, 2929, 348, 2930, 0, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, 361, 658, 659, 660, - 661, 362, 363, 0, 2931, 366, 367, 0, 369, 370, - 371, 665, 372, 373, 374, 375, 376, 377, 666, 378, - 379, 380, 381, 382, 1516, 384, 385, 386, 387, 668, - 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, - 398, 399, 400, 669, 401, 402, 2932, 404, 405, 406, - 1518, 408, 409, 410, 411, 412, 413, 414, 415, 416, - 417, 418, 419, 420, 672, 2933, 421, 422, 423, 424, - 425, 426, 2934, 428, 429, 675, 2935, 431, 432, 1522, - 434, 678, 435, 436, 437, 438, 439, 440, 441, 442, - 443, 444, 445, 446, 2936, 448, 0, 681, 682, 450, - 451, 683, 452, 2937, 454, 455, 456, 457, 458, 685, - 459, 1525, 1526, 688, 689, 462, 463, 0, 465, 0, - 692, 467, 468, 2938, 470, 471, 472, 473, 474, 2939, - 695, 475, 476, 477, 696, 478, 479, 480, 481, 697, - 482, 483, 484, 485, 486, 0, 1529, 700, 489, 2940, - 491, 492, 493, 494, 495, 496, 497, 702, 703, 498, - 704, 705, 499, 500, 501, 502, 503, 504, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 516, - 517, 518, 519, 0, 527, 0, 2044, 2045, 2046, 2038, - 2941, 2942, 2049, 2050, 2051, 2052, 2039, 2040, 0, 0, - 2041, 2042, 2043, 118, 119, 120, 121, 122, 123, 124, - 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, - 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, + 516, 517, 518, 519, 970, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 2456, 3240, 0, 118, 119, 120, 121, 122, 123, 124, + 125, 0, 126, 127, 128, 3, 4, 0, 564, 0, + 0, 0, 0, 569, 130, 131, 0, 132, 133, 134, + 571, 136, 137, 138, 572, 573, 574, 575, 576, 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, - 152, 153, 154, 155, 156, 0, 157, 158, 159, 160, - 161, 0, 0, 0, 163, 164, 165, 166, 167, 168, - 0, 170, 171, 172, 0, 173, 174, 175, 176, 177, - 178, 0, 0, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, - 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, + 152, 153, 580, 581, 156, 0, 157, 158, 159, 160, + 583, 0, 585, 0, 587, 164, 165, 166, 167, 168, + 588, 170, 171, 172, 0, 173, 174, 175, 176, 177, + 178, 0, 591, 180, 181, 182, 183, 184, 185, 186, + 187, 188, 189, 593, 191, 192, 594, 194, 0, 195, + 0, 196, 197, 198, 199, 200, 201, 14, 15, 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, - 0, 235, 0, 0, 0, 238, 239, 528, 0, 242, - 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, - 250, 251, 252, 253, 254, 0, 256, 257, 258, 259, + 218, 219, 220, 604, 222, 223, 224, 225, 226, 227, + 605, 0, 229, 0, 230, 231, 608, 233, 0, 234, + 0, 235, 611, 23, 613, 238, 239, 614, 615, 242, + 0, 243, 0, 618, 619, 246, 247, 0, 248, 249, + 250, 251, 252, 253, 254, 621, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, - 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, - 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, - 286, 287, 288, 0, 0, 289, 0, 291, 0, 0, - 293, 294, 295, 296, 297, 298, 299, 300, 529, 302, + 624, 625, 270, 271, 272, 273, 274, 626, 627, 0, + 629, 0, 278, 631, 632, 281, 633, 283, 284, 285, + 286, 287, 288, 0, 0, 289, 636, 291, 637, 0, + 293, 294, 295, 296, 297, 298, 299, 300, 639, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 0, 324, 325, 326, 327, 328, 0, 329, 330, 0, - 332, 0, 333, 334, 335, 336, 337, 338, 0, 339, + 313, 314, 315, 316, 317, 318, 319, 320, 321, 640, + 641, 642, 325, 326, 327, 643, 0, 329, 330, 645, + 332, 0, 647, 334, 648, 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, 343, 0, 0, 344, 345, - 346, 0, 348, 0, 350, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, - 362, 363, 364, 0, 366, 367, 368, 369, 370, 371, + 654, 655, 348, 656, 657, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, 361, 26, 27, 28, 0, + 362, 363, 662, 663, 366, 367, 664, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, - 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, + 380, 381, 382, 667, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, - 399, 400, 0, 401, 402, 0, 404, 405, 406, 407, + 399, 400, 0, 401, 402, 670, 404, 405, 406, 671, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, - 426, 427, 428, 429, 0, 0, 431, 432, 433, 434, + 418, 419, 420, 33, 673, 421, 422, 423, 424, 425, + 426, 674, 428, 429, 35, 676, 431, 432, 677, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, - 444, 445, 446, 530, 448, 449, 0, 0, 450, 451, - 0, 452, 0, 454, 455, 456, 457, 458, 0, 459, - 460, 461, 0, 0, 462, 463, 464, 465, 466, 0, - 467, 468, 469, 470, 471, 472, 473, 474, 0, 0, - 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, - 483, 484, 485, 486, 487, 488, 0, 489, 0, 491, + 444, 445, 446, 679, 448, 680, 37, 0, 450, 451, + 38, 452, 684, 454, 455, 456, 457, 458, 0, 459, + 686, 687, 0, 0, 462, 463, 690, 465, 691, 0, + 467, 468, 693, 470, 471, 472, 473, 474, 0, 0, + 475, 476, 477, 40, 478, 479, 480, 481, 0, 482, + 483, 484, 485, 486, 971, 699, 0, 489, 701, 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, - 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, - 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, - 518, 519, 0, 0, 0, 2044, 2045, 2046, 0, 2047, - 2048, 2049, 2050, 2051, 2052, 1612, 0, 0, 1613, 0, - 0, 0, 1614, 1615, 1616, 1617, 1618, 1619, 1620, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1621, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1623, 1612, 0, 0, 1613, 0, 0, - 1624, 1614, 1615, 1616, 1617, 1618, 1619, 1620, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1621, 0, 0, 0, 0, 1625, 0, 0, - 0, 0, 1623, 1612, 0, 0, 1613, 0, 0, 1624, - 1614, 1615, 1616, 1617, 1618, 1619, 1620, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1621, 0, 0, 0, 0, 1625, 0, 0, 0, - 0, 1623, 0, 0, 0, 0, 0, 0, 1624, 0, - 1612, 0, 0, 1613, 0, 0, 0, 1614, 1615, 1616, - 1617, 1618, 1619, 1620, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1625, 0, 0, 1621, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1623, 1612, - 0, 0, 1613, 0, 1626, 1624, 1614, 1615, 1616, 1617, - 1618, 1619, 1620, 0, 0, 0, 0, 0, 0, 0, - 0, 1627, 0, 0, 0, 0, 1628, 1621, 0, 0, - 0, 0, 1625, 0, 0, 0, 0, 1623, 0, 0, - 0, 0, 0, 1626, 1624, 0, 0, 0, 0, 1629, - 1630, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1627, 0, 0, 0, 1631, 1628, 0, 0, 0, 0, - 0, 1625, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1626, 0, 0, 0, 0, 0, 1629, 1630, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1627, - 0, 0, 1632, 1631, 1628, 1633, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1634, - 0, 0, 1635, 0, 0, 0, 0, 1629, 1630, 1626, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1632, 1631, 0, 1633, 0, 1627, 0, 0, 0, - 0, 1628, 0, 0, 0, 0, 0, 0, 1634, 0, - 0, 1635, 0, 0, 0, 0, 0, 0, 1626, 0, - 0, 0, 0, 0, 1629, 1630, 0, 0, 0, 0, - 1632, 0, 0, 1633, 0, 1627, 0, 0, 0, 1631, - 1628, 0, 0, 0, 0, 0, 0, 1634, 0, 0, - 1635, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1629, 1630, 0, 0, 0, 0, 0, - 0, 1636, 0, 0, 0, 0, 0, 1632, 1631, 0, - 1633, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1634, 0, 0, 1635, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1636, 0, 0, 0, 0, 0, 1632, 0, 0, 1633, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1634, 0, 0, 1635, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1636, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1637, 0, - 0, 1638, 1639, 1640, 0, 1641, 1642, 1643, 1644, 1645, - 1646, 0, 0, 0, 0, 3077, 1636, 0, 0, 0, - 0, 0, 1612, 0, 0, 1613, 0, 0, 0, 1614, - 1615, 1616, 1617, 1618, 1619, 1620, 0, 1637, 0, 0, - 1638, 1639, 1640, 0, 1641, 1642, 1643, 1644, 1645, 1646, - 1621, 0, 0, 0, 3084, 1636, 0, 0, 0, 0, - 1623, 0, 0, 0, 0, 0, 0, 1624, 0, 0, - 0, 0, 0, 0, 0, 0, 1637, 0, 0, 1638, - 1639, 1640, 0, 1641, 1642, 1643, 1644, 1645, 1646, 0, - 0, 0, 0, 3244, 1625, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1612, 0, - 0, 1613, 0, 0, 0, 1614, 1615, 1616, 1617, 1618, - 1619, 1620, 0, 1637, 0, 0, 1638, 1639, 1640, 0, - 1641, 1642, 1643, 1644, 1645, 1646, 1621, 0, 0, 0, - 3266, 0, 0, 0, 0, 0, 1623, 1612, 0, 0, - 1613, 0, 0, 1624, 1614, 1615, 1616, 1617, 1618, 1619, - 1620, 0, 1637, 0, 0, 1638, 1639, 1640, 0, 1641, - 1642, 1643, 1644, 1645, 1646, 1621, 0, 0, 0, 3367, - 1625, 0, 0, 0, 0, 1623, 1612, 0, 0, 1613, - 0, 1626, 1624, 1614, 1615, 1616, 1617, 1618, 1619, 1620, - 0, 0, 0, 0, 0, 0, 0, 0, 1627, 0, - 0, 0, 0, 1628, 1621, 0, 0, 0, 0, 1625, - 0, 0, 0, 0, 1623, 0, 0, 0, 0, 0, - 0, 1624, 0, 0, 0, 0, 1629, 1630, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1631, 0, 0, 0, 0, 0, 0, 1625, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1612, 0, 0, 1613, 0, 1626, 0, 1614, - 1615, 1616, 1617, 1618, 1619, 1620, 0, 0, 0, 1632, - 0, 0, 1633, 0, 1627, 0, 0, 0, 0, 1628, - 1621, 0, 0, 0, 0, 0, 1634, 0, 0, 1635, - 1623, 0, 0, 0, 0, 0, 1626, 1624, 0, 0, - 0, 0, 1629, 1630, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1627, 0, 0, 0, 1631, 1628, 0, - 0, 0, 0, 0, 1625, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1626, 0, 0, 0, 0, - 0, 1629, 1630, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1627, 0, 0, 1632, 1631, 1628, 1633, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1634, 0, 0, 1635, 0, 0, 0, 0, - 1629, 1630, 0, 0, 0, 0, 0, 0, 1636, 0, - 0, 0, 0, 0, 1632, 1631, 0, 1633, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1634, 0, 0, 1635, 0, 0, 0, 0, 0, - 0, 1626, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1632, 0, 0, 1633, 0, 1627, 0, - 0, 0, 0, 1628, 0, 0, 0, 0, 0, 0, - 1634, 0, 0, 1635, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1629, 1630, 0, 0, - 0, 0, 0, 0, 1636, 0, 0, 0, 0, 0, - 0, 1631, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1637, 0, 0, 1638, 1639, - 1640, 0, 1641, 1642, 1643, 1644, 1645, 1646, 0, 0, - 0, 0, 3424, 1636, 0, 0, 0, 0, 0, 1632, - 0, 0, 1633, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1634, 0, 0, 1635, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1636, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1637, 0, 0, 1638, 1639, 1640, 0, 1641, 1642, - 1643, 1644, 1645, 1646, 0, 0, 0, 0, 3446, 0, - 0, 0, 0, 0, 0, 1612, 0, 0, 1613, 0, - 0, 0, 1614, 1615, 1616, 1617, 1618, 1619, 1620, 0, - 1637, 0, 0, 1638, 1639, 1640, 0, 1641, 1642, 1643, - 1644, 1645, 1646, 1621, 0, 1801, 0, 0, 1636, 0, - 0, 0, 0, 1623, 0, 0, 0, 0, 0, 0, - 1624, 0, 0, 0, 0, 0, 0, 0, 0, 1637, - 0, 0, 1638, 1639, 1640, 0, 1641, 1642, 1643, 1644, - 1645, 1646, 0, 0, 2804, 0, 0, 1625, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1637, 0, 0, 1638, 1639, - 1640, 0, 1641, 1642, 1643, 1644, 1645, 1646, 0, 0, - 3234, 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, 1627, 0, 0, 0, 0, 1628, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1629, - 1630, 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, 0, 0, 0, 0, 0, 0, 0, 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, 0, 0, 0, 1634, - 0, 0, 1635, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1636, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 559, 0, 0, 1637, 0, - 0, 1638, 1639, 1640, 0, 1641, 1642, 1643, 1644, 1645, - 1646, 0, 0, 3408, 118, 119, 120, 121, 122, 123, - 124, 125, 560, 126, 127, 128, 561, 562, 563, 564, - 565, 566, 567, 568, 569, 130, 131, 570, 132, 133, - 134, 571, 136, 137, 138, 572, 573, 574, 575, 576, - 577, 144, 145, 146, 147, 148, 149, 578, 579, 150, - 151, 152, 153, 580, 581, 156, 582, 157, 158, 159, - 160, 583, 584, 585, 586, 587, 164, 165, 166, 167, - 168, 588, 170, 171, 172, 589, 173, 174, 175, 176, - 177, 178, 590, 591, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 593, 191, 192, 594, 194, 595, - 195, 596, 196, 197, 198, 199, 200, 201, 597, 598, - 202, 203, 204, 205, 599, 600, 206, 207, 208, 209, - 210, 601, 211, 212, 213, 602, 214, 215, 216, 603, - 217, 218, 219, 220, 604, 222, 223, 224, 225, 226, - 227, 605, 606, 229, 607, 230, 231, 608, 233, 609, - 234, 610, 235, 611, 612, 613, 238, 239, 614, 615, - 242, 616, 243, 617, 618, 619, 246, 247, 620, 248, - 249, 250, 251, 252, 253, 254, 621, 256, 257, 258, - 259, 622, 260, 261, 262, 263, 264, 265, 266, 623, - 267, 624, 625, 270, 271, 272, 273, 274, 626, 627, - 628, 629, 630, 278, 631, 632, 281, 633, 283, 284, - 285, 286, 287, 288, 634, 635, 289, 636, 291, 637, - 638, 293, 294, 295, 296, 297, 298, 299, 300, 639, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, - 640, 641, 642, 325, 326, 327, 643, 644, 329, 330, - 645, 332, 646, 647, 334, 648, 336, 337, 338, 649, - 339, 340, 650, 651, 341, 342, 343, 652, 653, 344, - 345, 654, 655, 348, 656, 657, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, 361, 658, 659, 660, - 661, 362, 363, 662, 663, 366, 367, 664, 369, 370, - 371, 665, 372, 373, 374, 375, 376, 377, 666, 378, - 379, 380, 381, 382, 667, 384, 385, 386, 387, 668, - 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, - 398, 399, 400, 669, 401, 402, 670, 404, 405, 406, - 671, 408, 409, 410, 411, 412, 413, 414, 415, 416, - 417, 418, 419, 420, 672, 673, 421, 422, 423, 424, - 425, 426, 674, 428, 429, 675, 676, 431, 432, 677, - 434, 678, 435, 436, 437, 438, 439, 440, 441, 442, - 443, 444, 445, 446, 679, 448, 680, 681, 682, 450, - 451, 683, 452, 684, 454, 455, 456, 457, 458, 685, - 459, 686, 687, 688, 689, 462, 463, 690, 465, 691, - 692, 467, 468, 693, 470, 471, 472, 473, 474, 694, - 695, 475, 476, 477, 696, 478, 479, 480, 481, 697, - 482, 483, 484, 485, 486, 698, 699, 700, 489, 701, - 491, 492, 493, 494, 495, 496, 497, 702, 703, 498, - 704, 705, 499, 500, 501, 502, 503, 504, 706, 707, - 708, 709, 710, 711, 712, 713, 714, 715, 716, 516, - 517, 518, 519, 527, 0, 0, 0, 0, 0, 0, - 0, 0, 2073, 0, 0, 0, 0, 0, 0, 0, + 44, 499, 500, 501, 502, 503, 504, 706, 707, 708, + 709, 710, 711, 712, 713, 714, 715, 716, 516, 517, + 518, 519, 0, 117, 45, 553, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 46, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, - 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, - 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, - 153, 154, 155, 156, 0, 157, 158, 159, 160, 161, - 0, 0, 0, 163, 164, 165, 166, 167, 168, 0, + 0, 0, 129, 130, 131, 0, 132, 133, 134, 135, + 136, 137, 138, 139, 140, 141, 142, 143, 0, 144, + 145, 146, 147, 148, 149, 0, 789, 150, 151, 152, + 153, 154, 155, 156, 0, 157, 158, 159, 160, 790, + 0, 791, 0, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, - 0, 0, 180, 181, 182, 183, 184, 185, 186, 187, + 0, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, - 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, + 196, 197, 198, 199, 200, 201, 14, 15, 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, - 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 792, 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, - 235, 0, 0, 0, 238, 239, 528, 0, 242, 0, + 235, 236, 23, 237, 238, 239, 240, 241, 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, - 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, - 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 0, + 260, 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, - 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, - 287, 288, 0, 0, 289, 0, 291, 0, 0, 293, - 294, 295, 296, 297, 298, 299, 300, 529, 302, 303, + 0, 278, 279, 280, 281, 282, 283, 284, 285, 286, + 287, 288, 793, 0, 289, 290, 291, 292, 0, 293, + 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 321, 322, 0, - 324, 325, 326, 327, 328, 0, 329, 330, 0, 332, - 0, 333, 334, 335, 336, 337, 338, 0, 339, 340, - 0, 0, 341, 342, 343, 0, 0, 344, 345, 346, - 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, - 363, 364, 0, 366, 367, 368, 369, 370, 371, 0, + 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, + 324, 325, 326, 327, 328, 0, 329, 330, 331, 332, + 0, 794, 334, 335, 336, 337, 338, 0, 339, 340, + 0, 795, 341, 342, 343, 0, 0, 344, 345, 346, + 347, 348, 349, 796, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 360, 361, 26, 27, 28, 0, 362, + 363, 797, 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, - 400, 0, 401, 402, 0, 404, 405, 406, 407, 408, + 400, 0, 401, 402, 403, 404, 405, 406, 407, 798, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, - 419, 420, 0, 0, 421, 422, 423, 424, 425, 426, - 427, 428, 429, 0, 0, 431, 432, 433, 434, 0, + 419, 420, 33, 0, 421, 422, 423, 424, 425, 426, + 427, 428, 429, 35, 430, 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, - 445, 446, 530, 448, 449, 0, 0, 450, 451, 0, - 452, 0, 454, 455, 456, 457, 458, 0, 459, 460, - 461, 0, 0, 462, 463, 464, 465, 466, 0, 467, - 468, 469, 470, 471, 472, 473, 474, 0, 0, 475, - 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, - 484, 485, 486, 487, 488, 0, 489, 0, 491, 492, - 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, + 445, 446, 447, 448, 799, 37, 0, 450, 451, 38, + 452, 453, 454, 455, 456, 457, 458, 0, 459, 460, + 461, 0, 0, 462, 463, 800, 465, 801, 0, 467, + 468, 802, 470, 471, 472, 473, 474, 0, 0, 475, + 476, 477, 40, 478, 479, 480, 481, 0, 482, 483, + 484, 485, 486, 803, 488, 0, 489, 490, 491, 492, + 493, 494, 495, 496, 497, 0, 0, 498, 0, 44, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, - 519, 527, 0, 0, 0, 0, 0, 0, 0, 0, - 2704, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, - 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, - 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, - 147, 148, 149, 0, 0, 150, 151, 152, 153, 154, - 155, 156, 0, 157, 158, 159, 160, 161, 0, 0, - 0, 163, 164, 165, 166, 167, 168, 0, 170, 171, - 172, 0, 173, 174, 175, 176, 177, 178, 0, 0, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, - 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, - 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, - 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 227, 228, 0, 229, - 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, - 0, 0, 238, 239, 528, 0, 242, 0, 243, 0, - 244, 245, 246, 247, 0, 248, 249, 250, 251, 252, - 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, - 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, - 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, - 0, 0, 281, 0, 283, 284, 285, 286, 287, 288, - 0, 0, 289, 0, 291, 0, 0, 293, 294, 295, - 296, 297, 298, 299, 300, 529, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 322, 0, 324, 325, - 326, 327, 328, 0, 329, 330, 0, 332, 0, 333, - 334, 335, 336, 337, 338, 0, 339, 340, 0, 0, - 341, 342, 343, 0, 0, 344, 345, 346, 0, 348, - 0, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, 361, 0, 0, 0, 0, 362, 363, 364, - 0, 366, 367, 368, 369, 370, 371, 0, 372, 373, - 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, - 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, - 401, 402, 0, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, - 429, 0, 0, 431, 432, 433, 434, 0, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - 530, 448, 449, 0, 0, 450, 451, 0, 452, 0, - 454, 455, 456, 457, 458, 0, 459, 460, 461, 0, - 0, 462, 463, 464, 465, 466, 0, 467, 468, 469, - 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, - 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, - 486, 487, 488, 0, 489, 0, 491, 492, 493, 494, - 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 516, 517, 518, 519, 968, - 1345, 819, 0, 0, 0, 1048, 0, 0, 2707, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, - 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, - 0, 0, 0, 564, 0, 0, 0, 0, 569, 130, - 131, 0, 132, 133, 134, 571, 136, 137, 138, 572, - 573, 574, 575, 576, 0, 144, 145, 146, 147, 148, - 149, 0, 0, 150, 151, 152, 153, 580, 581, 156, - 0, 157, 158, 159, 160, 583, 0, 585, 0, 587, - 164, 165, 166, 167, 168, 588, 170, 171, 172, 0, - 173, 174, 175, 176, 177, 178, 0, 591, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 189, 593, 191, - 192, 594, 194, 0, 195, 0, 196, 197, 198, 199, - 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, - 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, - 214, 215, 216, 0, 217, 218, 219, 220, 604, 222, - 223, 224, 225, 226, 227, 605, 1346, 229, 0, 230, - 231, 608, 233, 0, 234, 0, 235, 611, 0, 613, - 238, 239, 614, 615, 242, 0, 243, 0, 618, 619, - 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, - 621, 256, 257, 258, 259, 0, 260, 261, 262, 263, - 264, 265, 266, 0, 267, 624, 625, 270, 271, 272, - 273, 274, 626, 627, 0, 629, 0, 278, 631, 632, - 281, 633, 283, 284, 285, 286, 287, 288, 0, 0, - 289, 636, 291, 637, 0, 293, 294, 295, 296, 297, - 298, 299, 300, 639, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, 321, 640, 641, 642, 325, 326, 327, - 643, 0, 329, 330, 645, 332, 0, 647, 334, 648, - 336, 337, 338, 0, 339, 340, 1347, 0, 341, 342, - 343, 0, 0, 344, 345, 654, 655, 348, 656, 657, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - 361, 0, 0, 0, 0, 362, 363, 662, 663, 366, - 367, 664, 369, 370, 371, 0, 372, 373, 374, 375, - 376, 377, 0, 378, 379, 380, 381, 382, 667, 384, - 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, - 670, 404, 405, 406, 671, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 417, 418, 419, 420, 0, 673, - 421, 422, 423, 424, 425, 426, 674, 428, 429, 0, - 676, 431, 432, 677, 434, 0, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 445, 446, 679, 448, - 680, 0, 0, 450, 451, 0, 452, 684, 454, 455, - 456, 457, 458, 0, 459, 686, 687, 0, 0, 462, - 463, 690, 465, 691, 1348, 467, 468, 693, 470, 471, - 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, - 479, 480, 481, 0, 482, 483, 484, 485, 486, 698, - 699, 0, 489, 701, 491, 492, 493, 494, 495, 496, - 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, - 503, 504, 706, 707, 708, 709, 710, 711, 712, 713, - 714, 715, 716, 516, 517, 518, 519, 0, 0, 1612, - 0, 0, 1613, 0, 1349, 1350, 1614, 1615, 1616, 1617, - 1618, 1619, 1620, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1621, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1623, 1612, 0, - 0, 1613, 0, 0, 1624, 1614, 1615, 1616, 1617, 1618, - 1619, 1620, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1621, 0, 0, 0, - 0, 1625, 0, 0, 0, 0, 1623, 1612, 0, 0, - 1613, 0, 0, 1624, 1614, 1615, 1616, 1617, 1618, 1619, - 1620, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1621, 0, 0, 0, 1894, - 1625, 0, 0, 0, 0, 1623, 0, 0, 0, 0, - 0, 0, 1624, 0, 0, 0, 1612, 0, 0, 1613, - 0, 0, 0, 1614, 1615, 1616, 1617, 1618, 1619, 1620, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1625, - 0, 0, 0, 0, 1621, 0, 0, 0, 1930, 0, - 0, 0, 0, 1931, 1623, 0, 0, 0, 1626, 0, - 0, 1624, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1627, 0, 0, 0, 0, - 1628, 0, 0, 0, 0, 0, 3514, 0, 1625, 0, - 0, 0, 0, 0, 0, 0, 0, 1626, 0, 0, - 0, 0, 0, 1629, 1630, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1627, 0, 0, 0, 1631, 1628, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1626, 0, 0, 0, - 0, 0, 1629, 1630, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1627, 0, 0, 1632, 1631, 1628, 1633, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1634, 0, 0, 1635, 0, 0, 0, - 0, 1629, 1630, 0, 0, 1626, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1632, 1631, 0, 1633, 0, - 0, 0, 1627, 0, 0, 0, 0, 1628, 0, 0, - 0, 0, 1634, 0, 0, 1635, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1629, 1630, 0, 0, 1632, 0, 0, 1633, 0, 0, - 0, 0, 0, 0, 3515, 1631, 0, 0, 0, 0, - 0, 1634, 0, 0, 1635, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1636, 0, 0, 0, 0, - 0, 0, 0, 1632, 0, 0, 1633, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1634, 0, 0, 1635, 0, 0, 0, 0, 0, 1612, - 0, 0, 1613, 0, 1636, 0, 1614, 1615, 1616, 1617, - 1618, 1619, 1620, 0, 0, 0, 1901, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1621, 0, 0, - 0, 1936, 0, 0, 0, 0, 0, 1623, 0, 0, - 0, 0, 0, 1636, 1624, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1625, 1637, 0, 0, 1638, 1639, 1640, 0, 1641, - 1642, 1643, 1644, 1645, 1646, 0, 0, 0, 0, 0, - 0, 0, 1636, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1637, 0, 0, 1638, 1639, 1640, 0, 1641, 1642, - 1643, 1644, 1645, 1646, 0, 0, 0, 0, 1612, 0, - 0, 1613, 0, 0, 0, 1614, 1615, 1616, 1617, 1618, - 1619, 1620, 0, 0, 0, 0, 0, 0, 0, 0, - 1637, 0, 0, 1638, 1639, 1640, 1621, 1641, 1642, 1643, - 1644, 1645, 1646, 0, 0, 0, 1623, 0, 1626, 0, - 0, 0, 0, 1624, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1627, 0, 0, 0, 0, - 1628, 0, 0, 0, 0, 0, 0, 0, 0, 1637, - 1625, 0, 1638, 1639, 1640, 0, 1641, 1642, 1643, 1644, - 1645, 1646, 0, 1629, 1630, 0, 0, 0, 0, 0, - 0, 0, 0, 1612, 0, 0, 1613, 0, 1631, 0, - 1614, 1615, 1616, 1617, 1618, 1619, 1620, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1621, 0, 0, 0, 1943, 0, 0, 0, 0, - 0, 1623, 0, 0, 0, 0, 1632, 0, 1624, 1633, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1634, 0, 0, 1635, 0, 0, 0, - 0, 0, 1941, 0, 0, 1625, 0, 1626, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1627, 0, 0, 0, 0, 1628, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1629, 1630, 0, 0, 0, 0, 0, 0, - 0, 0, 1612, 0, 0, 1613, 0, 1631, 0, 1614, - 1615, 1616, 1617, 1618, 1619, 1620, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1621, 0, 0, 0, 0, 1636, 0, 0, 0, 0, - 1623, 0, 1626, 0, 0, 1632, 0, 1624, 1633, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1627, - 0, 0, 1634, 0, 1628, 1635, 0, 0, 0, 0, - 0, 0, 0, 0, 1625, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1629, 1630, 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, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1632, 0, 1637, 1633, 0, 1638, 1639, 1640, 0, 1641, - 1642, 1643, 1644, 1645, 1646, 0, 0, 1634, 0, 0, - 1635, 2066, 0, 0, 1636, 0, 1612, 0, 0, 1613, - 0, 1626, 0, 1614, 1615, 1616, 1617, 1618, 1619, 1620, - 0, 0, 0, 0, 0, 0, 0, 0, 1627, 0, - 0, 0, 0, 1628, 1621, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1623, 0, 0, 0, 0, 0, - 0, 1624, 0, 0, 0, 0, 1629, 1630, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1631, 0, 0, 0, 0, 0, 0, 1625, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1636, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1632, - 0, 1637, 1633, 0, 1638, 1639, 1640, 0, 1641, 1642, - 1643, 1644, 1645, 1646, 0, 0, 1634, 0, 0, 1635, - 0, 0, 0, 0, 0, 1612, 0, 0, 1613, 0, - 0, 0, 1614, 1615, 1616, 1617, 1618, 1619, 1620, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1621, 0, 0, 0, 2781, 0, 0, - 0, 0, 0, 1623, 0, 1626, 0, 0, 0, 0, - 1624, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1627, 0, 0, 0, 0, 1628, 0, 0, - 0, 0, 0, 0, 0, 0, 1637, 1625, 0, 1638, - 1639, 1640, 0, 1641, 1642, 1643, 1644, 1645, 1646, 0, - 1629, 1630, 0, 0, 0, 0, 0, 0, 1636, 0, - 1612, 0, 0, 1613, 0, 1631, 0, 1614, 1615, 1616, - 1617, 1618, 1619, 1620, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1621, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1623, 0, - 0, 0, 0, 1632, 0, 1624, 1633, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1634, 0, 0, 1635, 0, 0, 0, 0, 0, 0, - 0, 0, 1625, 0, 1626, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1627, 0, 0, 0, 0, 1628, 0, 0, 0, - 0, 0, 0, 0, 0, 1637, 0, 0, 1638, 1639, - 1640, 0, 1641, 1642, 1643, 1644, 1645, 1646, 0, 1629, - 1630, 0, 0, 0, 0, 0, 0, 0, 0, 1612, - 0, 0, 1613, 0, 1631, 0, 1614, 1615, 1616, 1617, - 1618, 1619, 1620, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1621, 0, 0, - 0, 0, 1636, 0, 0, 0, 0, 1623, 0, 1626, - 0, 0, 1632, 0, 1624, 1633, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1627, 0, 0, 1634, - 0, 1628, 1635, 0, 0, 2768, 0, 0, 0, 0, - 0, 1625, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1629, 1630, 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, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1632, 0, 1637, - 1633, 0, 1638, 1639, 1640, 0, 1641, 1642, 1643, 1644, - 1645, 1646, 0, 0, 1634, 0, 0, 1635, 0, 0, - 0, 1636, 0, 1612, 0, 0, 1613, 0, 1626, 0, - 1614, 1615, 1616, 1617, 1618, 1619, 1620, 0, 0, 0, - 0, 0, 0, 0, 0, 1627, 0, 0, 0, 0, - 1628, 1621, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1623, 0, 0, 0, 0, 0, 0, 1624, 0, - 0, 0, 0, 1811, 1630, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1631, 0, - 0, 0, 0, 0, 0, 1625, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1612, 0, 0, 1613, - 0, 0, 0, 1614, 1615, 0, 1636, 1618, 1619, 1620, - 0, 0, 0, 0, 0, 0, 1632, 0, 1637, 1633, - 0, 1638, 1639, 1640, 1621, 1641, 1642, 1643, 1644, 1645, - 1646, 0, 0, 1634, 1623, 0, 1635, 0, 0, 0, - 0, 1624, 0, 1612, 0, 0, 1613, 0, 0, 0, - 1614, 1615, 0, 0, 1618, 1619, 1620, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1625, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1623, 1626, 0, 0, 0, 0, 0, 1624, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1627, - 0, 0, 0, 0, 1628, 0, 0, 0, 0, 0, - 0, 0, 0, 1637, 0, 1625, 1638, 1639, 1640, 0, - 1641, 1642, 1643, 1644, 1645, 1646, 0, 1629, 1630, 0, - 0, 0, 0, 0, 0, 1636, 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, 1626, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1632, 0, 1627, 1633, 0, 0, 0, 1628, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1634, 0, 0, - 1635, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1629, 1630, 1626, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1631, 0, 0, 0, 1627, - 0, 0, 0, 0, 1628, 0, 0, 0, 0, 0, - 0, 0, 1637, 0, 0, 1638, 1639, 1640, 0, 1641, - 1642, 1643, 1644, 1645, 1646, 0, 0, -2058, -2058, 0, - 0, 0, 0, 1632, 0, 0, 1633, 0, 0, 0, - 0, 0, 1631, 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, 1636, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, -2058, 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, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1636, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1637, 0, 0, 1638, - 1639, 1640, 0, 1641, 1642, 1643, 1644, 2196, 1646, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1636, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1637, - 0, 0, 1638, 1639, 1640, 0, 1641, 1642, 1643, 1644, - 1645, 1646, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 559, 0, 2089, 0, 0, 0, 1637, 0, 0, 1638, - 1639, 1640, 0, 1641, 1642, 1643, 1644, 1645, 1646, 118, - 119, 120, 121, 122, 123, 124, 125, 560, 126, 127, - 128, 561, 562, 563, 564, 565, 566, 567, 568, 569, - 130, 131, 570, 132, 133, 134, 571, 136, 137, 138, - 572, 573, 574, 575, 576, 577, 144, 145, 146, 147, - 148, 149, 578, 579, 150, 151, 152, 153, 580, 581, - 156, 582, 157, 158, 159, 160, 583, 584, 585, 586, - 587, 164, 165, 166, 167, 168, 588, 170, 171, 172, - 589, 173, 174, 175, 176, 177, 178, 590, 591, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 593, - 191, 192, 594, 194, 595, 195, 596, 196, 197, 198, - 199, 200, 201, 597, 598, 202, 203, 204, 205, 599, - 600, 206, 207, 208, 209, 210, 601, 211, 212, 213, - 602, 214, 215, 216, 603, 217, 218, 219, 220, 604, - 222, 223, 224, 225, 226, 227, 605, 606, 229, 607, - 230, 231, 608, 233, 609, 234, 610, 235, 611, 612, - 613, 238, 239, 614, 615, 242, 616, 243, 617, 618, - 619, 246, 247, 620, 248, 249, 250, 251, 252, 253, - 254, 621, 256, 257, 258, 259, 622, 260, 261, 262, - 263, 264, 265, 266, 623, 267, 624, 625, 270, 271, - 272, 273, 274, 626, 627, 628, 629, 630, 278, 631, - 632, 281, 633, 283, 284, 285, 286, 287, 288, 634, - 635, 289, 636, 291, 637, 638, 293, 294, 295, 296, - 297, 298, 299, 300, 639, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 640, 641, 642, 325, 326, - 327, 643, 644, 329, 330, 645, 332, 646, 647, 334, - 648, 336, 337, 338, 649, 339, 340, 650, 651, 341, - 342, 343, 652, 653, 344, 345, 654, 655, 348, 656, - 657, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, 361, 658, 659, 660, 661, 362, 363, 662, 663, - 366, 367, 664, 369, 370, 371, 665, 372, 373, 374, - 375, 376, 377, 666, 378, 379, 380, 381, 382, 667, - 384, 385, 386, 387, 668, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 669, 401, - 402, 670, 404, 405, 406, 671, 408, 409, 410, 411, - 412, 413, 414, 415, 416, 417, 418, 419, 420, 672, - 673, 421, 422, 423, 424, 425, 426, 674, 428, 429, - 675, 676, 431, 432, 677, 434, 678, 435, 436, 437, - 438, 439, 440, 441, 442, 443, 444, 445, 446, 679, - 448, 680, 681, 682, 450, 451, 683, 452, 684, 454, - 455, 456, 457, 458, 685, 459, 686, 687, 688, 689, - 462, 463, 690, 465, 691, 692, 467, 468, 693, 470, - 471, 472, 473, 474, 694, 695, 475, 476, 477, 696, - 478, 479, 480, 481, 697, 482, 483, 484, 485, 486, - 698, 699, 700, 489, 701, 491, 492, 493, 494, 495, - 496, 497, 702, 703, 498, 704, 705, 499, 500, 501, - 502, 503, 504, 706, 707, 708, 709, 710, 711, 712, - 713, 714, 715, 716, 516, 517, 518, 519, 559, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, - 121, 122, 123, 124, 125, 560, 126, 127, 128, 561, - 562, 563, 564, 565, 566, 567, 568, 569, 130, 131, - 570, 132, 133, 134, 571, 136, 137, 138, 572, 573, - 574, 575, 576, 577, 144, 145, 146, 147, 148, 149, - 578, 579, 150, 151, 152, 153, 580, 581, 156, 582, - 157, 158, 159, 160, 583, 584, 585, 586, 587, 164, - 165, 166, 167, 168, 588, 170, 171, 172, 589, 173, - 174, 175, 176, 177, 178, 590, 591, 180, 181, 182, - 183, 184, 185, 592, 187, 188, 189, 593, 191, 192, - 594, 194, 595, 195, 596, 196, 197, 198, 199, 200, - 201, 597, 598, 202, 203, 204, 205, 599, 600, 206, - 207, 208, 209, 210, 601, 211, 212, 213, 602, 214, - 215, 216, 603, 217, 218, 219, 220, 604, 222, 223, - 224, 225, 226, 227, 605, 606, 229, 607, 230, 231, - 608, 233, 609, 234, 610, 235, 611, 612, 613, 238, - 239, 614, 615, 242, 616, 243, 617, 618, 619, 246, - 247, 620, 248, 249, 250, 251, 252, 253, 254, 621, - 256, 257, 258, 259, 622, 260, 261, 262, 263, 264, - 265, 266, 623, 267, 624, 625, 270, 271, 272, 273, - 274, 626, 627, 628, 629, 630, 278, 631, 632, 281, - 633, 283, 284, 285, 286, 287, 288, 634, 635, 289, - 636, 291, 637, 638, 293, 294, 295, 296, 297, 298, - 299, 300, 639, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 640, 641, 642, 325, 326, 327, 643, - 644, 329, 330, 645, 332, 646, 647, 334, 648, 336, - 337, 338, 649, 339, 340, 650, 651, 341, 342, 343, - 652, 653, 344, 345, 654, 655, 348, 656, 657, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, - 658, 659, 660, 661, 362, 363, 662, 663, 366, 367, - 664, 369, 370, 371, 665, 372, 373, 374, 375, 376, - 377, 666, 378, 379, 380, 381, 382, 667, 384, 385, - 386, 387, 668, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 397, 398, 399, 400, 669, 401, 402, 670, - 404, 405, 406, 671, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 417, 418, 419, 420, 672, 673, 421, - 422, 423, 424, 425, 426, 674, 428, 429, 675, 676, - 431, 432, 677, 434, 678, 435, 436, 437, 438, 439, - 440, 441, 442, 443, 444, 445, 446, 679, 448, 680, - 681, 682, 450, 451, 683, 452, 684, 454, 455, 456, - 457, 458, 685, 459, 686, 687, 688, 689, 462, 463, - 690, 465, 691, 692, 467, 468, 693, 470, 471, 472, - 473, 474, 694, 695, 475, 476, 477, 696, 478, 479, - 480, 481, 697, 482, 483, 484, 485, 486, 698, 699, - 700, 489, 701, 491, 492, 493, 494, 495, 496, 497, - 702, 703, 498, 704, 705, 499, 500, 501, 502, 503, - 504, 706, 707, 708, 709, 710, 711, 712, 713, 714, - 715, 716, 516, 517, 518, 519, 559, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 560, 126, 127, 128, 561, 562, 563, - 564, 565, 566, 567, 568, 569, 130, 131, 570, 132, - 133, 134, 571, 136, 137, 138, 572, 573, 574, 575, - 576, 577, 144, 145, 146, 147, 148, 149, 578, 579, - 150, 151, 152, 153, 580, 581, 156, 582, 157, 158, - 159, 160, 583, 584, 585, 586, 587, 164, 165, 166, - 167, 168, 588, 170, 171, 172, 589, 173, 174, 175, - 176, 177, 178, 590, 591, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 593, 191, 192, 594, 194, - 595, 195, 596, 196, 197, 198, 199, 200, 201, 597, - 598, 202, 203, 204, 205, 599, 600, 206, 207, 208, - 209, 210, 601, 211, 212, 213, 602, 214, 215, 216, - 603, 217, 218, 219, 220, 604, 222, 223, 224, 225, - 226, 227, 605, 606, 229, 607, 230, 231, 608, 233, - 609, 234, 610, 235, 611, 612, 613, 238, 239, 614, - 615, 242, 616, 243, 617, 618, 619, 246, 247, 620, - 248, 249, 250, 251, 252, 944, 254, 621, 256, 257, - 258, 259, 622, 260, 261, 262, 263, 264, 265, 266, - 623, 267, 624, 625, 270, 271, 272, 273, 274, 626, - 627, 628, 629, 630, 278, 631, 632, 281, 633, 283, - 284, 285, 286, 287, 288, 634, 635, 289, 636, 291, - 637, 638, 293, 294, 295, 296, 297, 298, 299, 300, - 639, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 640, 641, 642, 325, 326, 327, 643, 644, 329, - 330, 645, 332, 646, 647, 334, 648, 336, 337, 338, - 649, 339, 340, 650, 651, 341, 342, 343, 652, 653, - 344, 345, 654, 655, 348, 656, 657, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 658, 659, - 660, 661, 362, 363, 662, 663, 366, 367, 664, 369, - 370, 371, 665, 372, 373, 374, 375, 376, 377, 666, - 378, 379, 380, 381, 382, 667, 384, 385, 386, 387, - 668, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 669, 401, 402, 670, 404, 405, - 406, 671, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 672, 673, 421, 422, 423, - 424, 425, 426, 674, 428, 429, 675, 676, 431, 432, - 677, 434, 678, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 679, 448, 680, 681, 682, - 450, 451, 683, 452, 684, 454, 455, 456, 457, 458, - 685, 459, 686, 687, 688, 689, 462, 463, 690, 465, - 691, 692, 467, 468, 693, 470, 471, 472, 473, 474, - 694, 695, 475, 476, 477, 696, 478, 479, 480, 481, - 697, 482, 483, 484, 485, 486, 698, 699, 700, 489, - 701, 491, 492, 493, 494, 495, 496, 497, 702, 703, - 498, 704, 705, 499, 500, 501, 502, 503, 504, 706, - 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, - 516, 517, 518, 519, 559, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, - 125, 560, 126, 127, 128, 561, 562, 563, 564, 565, - 566, 567, 568, 569, 130, 131, 570, 132, 133, 134, - 571, 136, 137, 138, 572, 573, 574, 575, 576, 577, - 144, 145, 146, 147, 148, 149, 578, 579, 150, 151, - 152, 153, 580, 581, 156, 582, 157, 158, 159, 160, - 583, 584, 585, 586, 587, 164, 165, 166, 167, 168, - 588, 170, 171, 172, 589, 173, 174, 175, 176, 177, - 178, 590, 591, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 593, 191, 192, 594, 194, 595, 195, - 596, 196, 197, 198, 199, 200, 201, 597, 598, 202, - 203, 204, 205, 599, 600, 206, 207, 208, 209, 210, - 601, 211, 212, 213, 602, 214, 215, 216, 603, 217, - 218, 219, 220, 604, 222, 223, 224, 225, 226, 227, - 605, 606, 229, 607, 230, 231, 608, 233, 609, 234, - 610, 235, 611, 612, 613, 238, 239, 614, 615, 242, - 616, 243, 617, 618, 619, 246, 247, 620, 248, 249, - 250, 251, 252, 253, 254, 621, 256, 257, 258, 259, - 622, 260, 261, 262, 263, 264, 265, 266, 623, 267, - 624, 625, 270, 271, 272, 273, 274, 626, 627, 628, - 629, 630, 278, 631, 632, 281, 633, 283, 284, 285, - 286, 287, 288, 634, 635, 289, 636, 291, 637, 638, - 293, 294, 295, 296, 297, 298, 299, 300, 639, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 640, - 641, 642, 325, 326, 327, 643, 644, 329, 330, 645, - 332, 646, 647, 334, 648, 336, 337, 338, 649, 339, - 340, 650, 651, 341, 342, 343, 652, 653, 344, 345, - 654, 655, 348, 656, 657, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, 361, 658, 659, 660, 661, - 362, 363, 662, 663, 366, 367, 664, 369, 370, 371, - 665, 372, 373, 374, 375, 376, 377, 666, 378, 379, - 380, 381, 382, 667, 384, 385, 386, 387, 668, 388, - 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, - 399, 400, 669, 401, 402, 670, 404, 405, 406, 671, - 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 672, 673, 421, 422, 423, 424, 425, - 426, 674, 428, 429, 675, 676, 431, 432, 677, 434, - 678, 435, 436, 437, 438, 439, 440, 441, 442, 443, - 444, 445, 446, 679, 448, 680, 681, 682, 450, 451, - 683, 452, 684, 454, 455, 456, 457, 458, 685, 459, - 686, 687, 688, 689, 462, 463, 690, 465, 691, 692, - 467, 468, 693, 470, 471, 472, 473, 474, 694, 695, - 475, 476, 477, 696, 478, 479, 480, 481, 697, 482, - 483, 484, 485, 486, 698, 699, 700, 489, 701, 491, - 492, 493, 494, 495, 496, 497, 702, 703, 498, 704, - 705, 499, 500, 501, 502, 503, 504, 706, 707, 708, - 709, 710, 711, 712, 713, 714, 715, 716, 516, 517, - 518, 519, 559, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 118, 119, 120, 121, 2241, 123, 124, 125, 560, - 126, 127, 128, 561, 562, 563, 564, 565, 566, 567, - 568, 569, 130, 131, 570, 132, 133, 134, 571, 136, - 137, 138, 572, 573, 574, 575, 576, 577, 144, 145, - 146, 147, 148, 149, 578, 579, 150, 151, 152, 153, - 580, 581, 156, 582, 157, 158, 159, 160, 583, 584, - 585, 586, 587, 164, 165, 166, 167, 168, 588, 170, - 171, 172, 589, 173, 174, 175, 176, 177, 178, 590, - 591, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 189, 593, 191, 192, 594, 194, 595, 195, 596, 196, - 197, 198, 199, 200, 201, 597, 598, 202, 203, 204, - 205, 599, 600, 206, 207, 208, 2242, 210, 601, 211, - 212, 213, 602, 214, 215, 216, 603, 217, 218, 219, - 220, 604, 222, 223, 224, 225, 226, 227, 605, 606, - 229, 607, 230, 231, 608, 233, 609, 234, 610, 235, - 611, 612, 613, 238, 239, 614, 615, 242, 616, 243, - 617, 618, 619, 246, 247, 620, 248, 249, 250, 251, - 252, 253, 254, 621, 256, 257, 258, 259, 622, 260, - 261, 262, 263, 264, 265, 266, 623, 267, 624, 625, - 270, 271, 272, 273, 274, 626, 627, 628, 629, 630, - 278, 631, 632, 281, 633, 283, 284, 285, 286, 287, - 288, 634, 635, 289, 636, 291, 637, 638, 293, 294, - 295, 296, 297, 298, 299, 300, 639, 302, 303, 304, + 519, 0, 117, 45, 553, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 804, 0, 0, + 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, + 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, + 0, 129, 130, 131, 0, 132, 133, 134, 135, 136, + 137, 138, 139, 140, 141, 142, 143, 0, 144, 145, + 146, 147, 148, 149, 0, 789, 150, 151, 152, 153, + 154, 155, 156, 0, 157, 158, 159, 160, 790, 0, + 791, 0, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, + 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, + 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, + 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 227, 792, 0, + 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, + 236, 0, 237, 238, 239, 240, 241, 242, 0, 243, + 0, 244, 245, 246, 247, 0, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 793, 0, 289, 290, 291, 292, 0, 293, 294, + 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 640, 641, 642, - 325, 326, 327, 643, 644, 329, 330, 645, 332, 646, - 647, 334, 648, 336, 337, 338, 649, 339, 340, 650, - 651, 341, 342, 343, 652, 653, 344, 345, 654, 655, - 348, 656, 657, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, 361, 658, 659, 660, 661, 362, 363, - 662, 663, 366, 367, 664, 369, 370, 371, 665, 372, - 373, 374, 375, 376, 377, 666, 378, 379, 380, 381, - 382, 667, 384, 385, 386, 387, 668, 388, 389, 390, + 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, 0, 329, 330, 331, 332, 0, + 794, 334, 335, 336, 337, 338, 0, 339, 340, 0, + 795, 341, 342, 343, 0, 0, 344, 345, 346, 347, + 348, 349, 796, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, + 797, 365, 366, 367, 368, 369, 370, 371, 0, 372, + 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, + 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, - 669, 401, 402, 670, 404, 405, 406, 671, 408, 409, + 0, 401, 402, 403, 404, 405, 406, 407, 798, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, - 420, 672, 673, 421, 422, 423, 424, 425, 2243, 674, - 428, 429, 675, 676, 431, 432, 677, 434, 678, 435, + 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 0, 430, 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, - 446, 679, 448, 680, 681, 682, 450, 451, 683, 452, - 684, 454, 455, 456, 457, 458, 685, 459, 686, 687, - 688, 689, 462, 463, 690, 465, 691, 692, 467, 468, - 693, 470, 471, 472, 473, 474, 694, 695, 475, 476, - 477, 696, 478, 479, 480, 481, 697, 482, 483, 484, - 485, 486, 698, 699, 700, 489, 701, 491, 492, 493, - 494, 495, 496, 497, 702, 703, 498, 704, 705, 499, - 500, 501, 502, 503, 504, 706, 707, 708, 709, 710, - 711, 712, 713, 714, 715, 716, 516, 517, 518, 519, - 968, 0, 819, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, + 446, 447, 448, 799, 0, 0, 450, 451, 0, 452, + 453, 454, 455, 456, 457, 458, 0, 459, 460, 461, + 0, 0, 462, 463, 800, 465, 801, 0, 467, 468, + 802, 470, 471, 472, 473, 474, 0, 0, 475, 476, + 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, + 485, 486, 803, 488, 0, 489, 490, 491, 492, 493, + 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, + 117, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 804, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, - 128, 0, 0, 0, 564, 0, 0, 0, 0, 569, - 130, 131, 0, 132, 133, 134, 571, 136, 137, 138, - 572, 573, 574, 575, 576, 0, 144, 145, 146, 147, - 148, 149, 0, 0, 150, 151, 152, 153, 580, 581, - 156, 0, 157, 158, 159, 160, 583, 0, 585, 0, - 587, 164, 165, 166, 167, 168, 588, 170, 171, 172, - 0, 173, 174, 175, 176, 177, 178, 0, 591, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 593, - 191, 192, 594, 194, 0, 195, 0, 196, 197, 198, + 128, 0, 0, 0, 0, 0, 0, 0, 0, 129, + 130, 131, 0, 132, 133, 134, 135, 136, 137, 138, + 139, 140, 141, 142, 143, 0, 144, 145, 146, 147, + 148, 149, 0, 789, 150, 151, 152, 153, 154, 155, + 156, 0, 157, 158, 159, 160, 790, 0, 791, 0, + 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, + 0, 173, 174, 175, 176, 177, 178, 0, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, - 0, 214, 215, 216, 0, 217, 218, 219, 220, 604, - 222, 223, 224, 225, 226, 227, 605, 1346, 229, 0, - 230, 231, 608, 233, 0, 234, 0, 235, 611, 0, - 613, 238, 239, 614, 615, 242, 0, 243, 0, 618, - 619, 246, 247, 0, 248, 249, 250, 251, 252, 253, - 254, 621, 256, 257, 258, 259, 0, 260, 261, 262, - 263, 264, 265, 266, 0, 267, 624, 625, 270, 271, - 272, 273, 274, 626, 627, 0, 629, 0, 278, 631, - 632, 281, 633, 283, 284, 285, 286, 287, 288, 0, - 0, 289, 636, 291, 637, 0, 293, 294, 295, 296, - 297, 298, 299, 300, 639, 302, 303, 304, 305, 306, + 0, 214, 215, 216, 0, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 227, 792, 0, 229, 0, + 230, 231, 232, 233, 0, 234, 0, 235, 236, 0, + 237, 238, 239, 240, 241, 242, 0, 243, 0, 244, + 245, 246, 247, 0, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 0, 260, 261, 262, + 263, 264, 265, 266, 0, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 0, 277, 0, 278, 279, + 280, 281, 282, 283, 284, 285, 286, 287, 288, 0, + 0, 289, 290, 291, 292, 0, 293, 294, 295, 296, + 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 640, 641, 642, 325, 326, - 327, 643, 0, 329, 330, 645, 332, 0, 647, 334, - 648, 336, 337, 338, 0, 339, 340, 1347, 0, 341, - 342, 343, 0, 0, 344, 345, 654, 655, 348, 656, - 657, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, 361, 0, 0, 0, 0, 362, 363, 662, 663, - 366, 367, 664, 369, 370, 371, 0, 372, 373, 374, - 375, 376, 377, 0, 378, 379, 380, 381, 382, 667, + 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, + 327, 328, 0, 329, 330, 331, 332, 0, 794, 334, + 335, 336, 337, 338, 0, 339, 340, 0, 0, 341, + 342, 343, 0, 0, 344, 345, 346, 347, 348, 349, + 796, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, 361, 0, 0, 0, 0, 362, 363, 797, 365, + 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, + 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, - 402, 670, 404, 405, 406, 671, 408, 409, 410, 411, + 402, 403, 404, 405, 406, 407, 798, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, - 673, 421, 422, 423, 424, 425, 426, 674, 428, 429, - 0, 676, 431, 432, 677, 434, 0, 435, 436, 437, - 438, 439, 440, 441, 442, 443, 444, 445, 446, 679, - 448, 680, 0, 0, 450, 451, 0, 452, 684, 454, - 455, 456, 457, 458, 0, 459, 686, 687, 0, 0, - 462, 463, 690, 465, 691, 1348, 467, 468, 693, 470, + 0, 421, 422, 423, 424, 425, 426, 427, 428, 429, + 0, 430, 431, 432, 433, 434, 0, 435, 436, 437, + 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, + 448, 799, 0, 0, 450, 451, 0, 452, 453, 454, + 455, 456, 457, 458, 0, 459, 460, 461, 0, 0, + 462, 463, 800, 465, 801, 0, 467, 468, 802, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, - 698, 699, 0, 489, 701, 491, 492, 493, 494, 495, + 487, 488, 0, 489, 490, 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, - 502, 503, 504, 706, 707, 708, 709, 710, 711, 712, - 713, 714, 715, 716, 516, 517, 518, 519, 968, 0, + 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, + 512, 513, 514, 515, 516, 517, 518, 519, 117, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, - 121, 122, 123, 124, 125, 0, 126, 127, 128, 3, - 4, 0, 564, 0, 0, 0, 0, 569, 130, 131, - 0, 132, 133, 134, 571, 136, 137, 138, 572, 573, - 574, 575, 576, 0, 144, 145, 146, 147, 148, 149, - 0, 0, 150, 151, 152, 153, 580, 581, 156, 0, - 157, 158, 159, 160, 583, 0, 585, 0, 587, 164, - 165, 166, 167, 168, 588, 170, 171, 172, 0, 173, - 174, 175, 176, 177, 178, 0, 591, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 593, 191, 192, - 594, 194, 0, 195, 0, 196, 197, 198, 199, 200, + 0, 0, 0, 0, 46, 0, 0, 118, 119, 120, + 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, + 0, 0, 0, 0, 0, 0, 0, 129, 130, 131, + 0, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 0, 144, 145, 146, 147, 148, 149, + 0, 789, 150, 151, 152, 153, 154, 155, 156, 0, + 157, 158, 159, 160, 790, 0, 791, 0, 163, 164, + 165, 166, 167, 168, 169, 170, 171, 172, 0, 173, + 174, 175, 176, 177, 178, 0, 179, 180, 181, 182, + 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, + 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, - 215, 216, 0, 217, 218, 219, 220, 604, 222, 223, - 224, 225, 226, 227, 605, 0, 229, 0, 230, 231, - 608, 233, 0, 234, 0, 235, 611, 0, 613, 238, - 239, 614, 615, 242, 0, 243, 0, 618, 619, 246, - 247, 0, 248, 249, 250, 251, 252, 253, 254, 621, + 215, 216, 0, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 792, 0, 229, 0, 230, 231, + 232, 233, 0, 234, 0, 235, 236, 0, 237, 238, + 239, 240, 241, 242, 0, 243, 0, 244, 245, 246, + 247, 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, - 265, 266, 0, 267, 624, 625, 270, 271, 272, 273, - 274, 626, 627, 0, 629, 0, 278, 631, 632, 281, - 633, 283, 284, 285, 286, 287, 288, 0, 0, 289, - 636, 291, 637, 0, 293, 294, 295, 296, 297, 298, - 299, 300, 639, 302, 303, 304, 305, 306, 307, 308, + 265, 266, 0, 267, 268, 269, 270, 271, 272, 273, + 274, 275, 276, 0, 277, 0, 278, 279, 280, 281, + 282, 283, 284, 285, 286, 287, 288, 0, 0, 289, + 290, 291, 292, 0, 293, 294, 295, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 640, 641, 642, 325, 326, 327, 643, - 0, 329, 330, 645, 332, 0, 647, 334, 648, 336, + 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, + 0, 329, 330, 331, 332, 0, 794, 334, 335, 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, 343, - 0, 0, 344, 345, 654, 655, 348, 656, 657, 351, + 0, 0, 344, 345, 346, 347, 348, 349, 796, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, - 0, 0, 0, 0, 362, 363, 662, 663, 366, 367, - 664, 369, 370, 371, 0, 372, 373, 374, 375, 376, - 377, 0, 378, 379, 380, 381, 382, 667, 384, 385, + 0, 0, 0, 0, 362, 363, 797, 365, 366, 367, + 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, + 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 397, 398, 399, 400, 0, 401, 402, 670, - 404, 405, 406, 671, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 417, 418, 419, 420, 0, 673, 421, - 422, 423, 424, 425, 426, 674, 428, 429, 0, 676, - 431, 432, 677, 434, 0, 435, 436, 437, 438, 439, - 440, 441, 442, 443, 444, 445, 446, 679, 448, 680, - 0, 0, 450, 451, 0, 452, 684, 454, 455, 456, - 457, 458, 0, 459, 686, 687, 0, 0, 462, 463, - 690, 465, 691, 0, 467, 468, 693, 470, 471, 472, + 395, 396, 397, 398, 399, 400, 0, 401, 402, 403, + 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, + 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, + 422, 423, 424, 425, 426, 427, 428, 429, 0, 430, + 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, + 440, 441, 442, 443, 444, 445, 446, 447, 448, 799, + 0, 0, 450, 451, 0, 452, 453, 454, 455, 456, + 457, 458, 0, 459, 460, 461, 0, 0, 462, 463, + 800, 465, 801, 0, 467, 468, 802, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, - 480, 481, 0, 482, 483, 484, 485, 486, 698, 699, - 0, 489, 701, 491, 492, 493, 494, 495, 496, 497, + 480, 481, 0, 482, 483, 484, 485, 486, 487, 488, + 0, 489, 490, 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, - 504, 706, 707, 708, 709, 710, 711, 712, 713, 714, - 715, 716, 516, 517, 518, 519, 117, 0, 0, 0, + 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, + 514, 515, 516, 517, 518, 519, 527, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, + 0, 0, 3328, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 0, 0, 0, 0, 0, 129, 130, 131, 0, 132, - 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, - 143, 0, 144, 145, 146, 147, 148, 149, 0, 789, + 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, + 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, + 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, 154, 155, 156, 0, 157, 158, - 159, 160, 790, 0, 791, 0, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 179, 180, 181, 182, 183, 184, + 159, 160, 161, 0, 0, 0, 163, 164, 165, 166, + 167, 168, 0, 170, 171, 172, 0, 173, 174, 175, + 176, 177, 178, 0, 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, + 0, 195, 0, 196, 197, 198, 199, 200, 201, 14, + 15, 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 227, 792, 0, 229, 0, 230, 231, 232, 233, - 0, 234, 0, 235, 236, 0, 237, 238, 239, 240, - 241, 242, 0, 243, 0, 244, 245, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, + 0, 234, 0, 235, 0, 23, 0, 238, 239, 528, + 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, + 248, 249, 250, 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 275, - 276, 0, 277, 0, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 290, 291, - 292, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, + 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, + 284, 285, 286, 287, 288, 0, 0, 289, 0, 291, + 0, 0, 293, 294, 295, 296, 297, 298, 299, 300, + 529, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, 0, 329, - 330, 331, 332, 0, 794, 334, 335, 336, 337, 338, + 321, 322, 0, 324, 325, 326, 327, 328, 0, 329, + 330, 0, 332, 0, 333, 334, 335, 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, 343, 0, 0, - 344, 345, 346, 347, 348, 349, 796, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 797, 365, 366, 367, 368, 369, + 344, 345, 346, 0, 348, 0, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 360, 361, 26, 27, + 28, 0, 362, 363, 364, 0, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 403, 404, 405, + 397, 398, 399, 400, 0, 401, 402, 0, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 430, 431, 432, + 416, 417, 418, 419, 420, 33, 0, 421, 422, 423, + 424, 425, 426, 427, 428, 429, 35, 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 447, 448, 799, 0, 0, - 450, 451, 0, 452, 453, 454, 455, 456, 457, 458, - 0, 459, 460, 461, 0, 0, 462, 463, 800, 465, - 801, 0, 467, 468, 802, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 488, 0, 489, - 490, 491, 492, 493, 494, 495, 496, 497, 0, 0, - 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, + 442, 443, 444, 445, 446, 530, 448, 449, 37, 0, + 450, 451, 38, 452, 0, 454, 455, 456, 457, 458, + 0, 459, 460, 461, 0, 0, 462, 463, 464, 465, + 466, 0, 467, 468, 469, 470, 471, 472, 473, 474, + 0, 0, 475, 476, 477, 40, 478, 479, 480, 481, + 0, 482, 483, 484, 485, 486, 803, 488, 0, 489, + 0, 491, 492, 493, 494, 495, 496, 497, 0, 0, + 498, 0, 44, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 117, 0, 0, 0, 0, 0, + 516, 517, 518, 519, 527, 0, 45, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, - 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, - 0, 0, 0, 129, 130, 131, 0, 132, 133, 134, - 135, 136, 137, 138, 139, 140, 141, 142, 143, 0, + 46, 0, 0, 118, 119, 120, 121, 122, 123, 124, + 125, 890, 126, 127, 128, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, + 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, 154, 155, 156, 0, 157, 158, 159, 160, - 161, 0, 162, 0, 163, 164, 165, 166, 167, 168, - 169, 170, 171, 172, 0, 173, 174, 175, 176, 177, - 178, 0, 179, 180, 181, 182, 183, 184, 185, 186, + 161, 0, 0, 0, 163, 164, 165, 166, 167, 168, + 0, 170, 171, 172, 0, 173, 174, 175, 176, 177, + 178, 0, 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, - 0, 235, 236, 0, 237, 238, 239, 240, 241, 242, + 0, 235, 0, 23, 0, 238, 239, 528, 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 250, 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, - 268, 269, 270, 271, 272, 273, 274, 275, 276, 0, - 277, 0, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 0, 0, 289, 290, 291, 292, 0, - 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, + 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, + 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, + 286, 287, 288, 0, 0, 289, 0, 291, 0, 0, + 293, 294, 295, 296, 297, 298, 299, 300, 529, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, 0, 329, 330, 331, + 0, 324, 325, 326, 327, 328, 0, 329, 330, 0, 332, 0, 333, 334, 335, 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, 343, 0, 0, 344, 345, - 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, - 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 346, 0, 348, 0, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, 361, 26, 27, 28, 0, + 362, 363, 364, 0, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, - 399, 400, 0, 401, 402, 403, 404, 405, 406, 407, + 399, 400, 0, 401, 402, 0, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, - 426, 427, 428, 429, 0, 430, 431, 432, 433, 434, + 418, 419, 420, 33, 0, 421, 422, 423, 424, 425, + 426, 427, 428, 429, 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, - 444, 445, 446, 447, 448, 449, 0, 0, 450, 451, - 0, 452, 453, 454, 455, 456, 457, 458, 0, 459, - 460, 461, 0, 0, 462, 463, 464, 465, 466, 0, + 444, 445, 446, 530, 448, 449, 0, 0, 450, 451, + 38, 452, 0, 454, 455, 456, 457, 458, 0, 459, + 891, 461, 0, 0, 892, 463, 464, 465, 466, 0, 467, 468, 469, 470, 471, 472, 473, 474, 0, 0, - 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, - 483, 484, 485, 486, 487, 488, 0, 489, 490, 491, + 475, 476, 477, 40, 478, 479, 480, 481, 0, 482, + 483, 484, 485, 486, 803, 488, 0, 489, 0, 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, - 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, + 44, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, - 518, 519, 527, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 518, 519, 527, 0, 45, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 46, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, - 154, 155, 156, 1744, 157, 158, 159, 160, 161, 0, - 0, 1745, 163, 164, 165, 166, 167, 168, 0, 170, - 171, 172, 1746, 173, 174, 175, 176, 177, 178, 0, + 154, 155, 156, 0, 157, 158, 159, 160, 161, 0, + 0, 0, 163, 164, 165, 166, 167, 168, 0, 170, + 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 0, - 229, 0, 230, 231, 232, 233, 0, 234, 1747, 235, - 0, 0, 0, 238, 239, 528, 0, 242, 0, 243, + 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, + 0, 23, 0, 238, 239, 528, 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, 251, - 252, 1748, 254, 0, 256, 257, 258, 259, 0, 260, + 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, 287, @@ -8108,1122 +7751,803 @@ static const yytype_int16 yytable[] = 333, 334, 335, 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, 343, 0, 0, 344, 345, 346, 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, - 364, 0, 366, 367, 368, 369, 370, 371, 1749, 372, - 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, - 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, - 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, - 0, 401, 402, 0, 404, 405, 406, 407, 408, 409, - 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, - 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, - 428, 429, 0, 0, 431, 432, 433, 434, 0, 435, - 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, - 446, 530, 448, 449, 0, 0, 450, 451, 0, 452, - 0, 454, 455, 456, 457, 458, 0, 459, 460, 461, - 0, 0, 462, 463, 464, 465, 466, 0, 467, 468, - 469, 470, 471, 472, 473, 474, 0, 1750, 475, 476, - 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, - 485, 486, 487, 488, 0, 489, 0, 491, 492, 493, - 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, - 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, - 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, - 527, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, - 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, - 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, - 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, - 148, 149, 0, 0, 150, 151, 152, 153, 154, 155, - 156, 1744, 157, 158, 159, 160, 161, 0, 0, 0, - 163, 164, 165, 166, 167, 168, 0, 170, 171, 172, - 1746, 173, 174, 175, 176, 177, 178, 0, 0, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, - 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, - 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, - 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, - 0, 214, 215, 216, 0, 217, 218, 219, 220, 221, - 222, 223, 224, 225, 226, 227, 228, 0, 229, 0, - 230, 231, 232, 233, 0, 234, 1747, 235, 0, 0, - 0, 238, 239, 528, 0, 242, 0, 243, 0, 244, - 245, 246, 247, 0, 248, 249, 250, 251, 252, 253, - 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, - 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, - 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, - 0, 281, 0, 283, 284, 285, 286, 287, 288, 0, - 0, 289, 0, 291, 2323, 0, 293, 294, 295, 296, - 297, 298, 299, 300, 529, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 0, 324, 325, 326, - 327, 328, 0, 329, 330, 0, 332, 0, 333, 334, - 335, 336, 337, 338, 0, 339, 340, 0, 0, 341, - 342, 343, 0, 0, 344, 345, 346, 0, 348, 0, - 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, 361, 0, 0, 0, 0, 362, 363, 364, 0, - 366, 367, 368, 369, 370, 371, 1749, 372, 373, 374, - 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, - 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, - 402, 0, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, - 0, 421, 422, 423, 424, 425, 426, 427, 428, 429, - 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, - 438, 439, 440, 441, 442, 443, 444, 445, 446, 530, - 448, 449, 0, 0, 450, 451, 0, 452, 0, 454, - 455, 456, 457, 458, 0, 459, 460, 461, 0, 0, - 462, 463, 464, 465, 466, 0, 467, 468, 469, 470, - 471, 472, 473, 474, 0, 1750, 475, 476, 477, 0, - 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, - 487, 488, 0, 489, 0, 491, 492, 493, 494, 495, - 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, - 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, - 512, 513, 514, 515, 516, 517, 518, 519, 527, 0, - 553, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, - 121, 122, 123, 124, 125, 0, 126, 127, 128, 3, - 4, 0, 0, 0, 0, 0, 0, 0, 130, 131, - 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, - 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, - 0, 0, 150, 151, 152, 153, 154, 155, 156, 0, - 157, 158, 159, 160, 161, 0, 0, 0, 163, 164, - 165, 166, 167, 168, 0, 170, 171, 172, 0, 173, - 174, 175, 176, 177, 178, 0, 0, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, - 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, - 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, - 215, 216, 0, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, - 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, - 239, 528, 0, 242, 0, 243, 0, 244, 245, 246, - 247, 0, 248, 249, 250, 251, 252, 253, 254, 0, - 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, - 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, - 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, - 0, 283, 284, 285, 286, 287, 288, 0, 0, 289, - 0, 291, 0, 0, 293, 294, 295, 296, 297, 298, - 299, 300, 529, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 322, 0, 324, 325, 326, 327, 328, - 0, 329, 330, 0, 332, 0, 333, 334, 335, 336, - 337, 338, 0, 339, 340, 0, 0, 341, 342, 343, - 0, 0, 344, 345, 346, 0, 348, 0, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, - 0, 0, 0, 0, 362, 363, 364, 0, 366, 367, - 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, - 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, - 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 397, 398, 399, 400, 0, 401, 402, 0, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, - 422, 423, 424, 425, 426, 427, 428, 429, 0, 0, - 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, - 440, 441, 442, 443, 444, 445, 446, 530, 448, 449, - 0, 0, 450, 451, 0, 452, 0, 454, 455, 456, - 457, 458, 0, 459, 460, 461, 0, 0, 462, 463, - 464, 465, 466, 0, 467, 468, 469, 470, 471, 472, - 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, - 480, 481, 0, 482, 483, 484, 485, 486, 487, 488, - 0, 489, 0, 491, 492, 493, 494, 495, 496, 497, - 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, - 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, - 514, 515, 516, 517, 518, 519, 527, 0, 553, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 554, 126, 127, 128, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, - 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, - 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, - 150, 151, 152, 153, 154, 155, 156, 0, 157, 158, - 159, 160, 161, 0, 0, 0, 163, 164, 165, 166, - 167, 168, 0, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 0, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, - 0, 234, 0, 235, 0, 0, 0, 238, 239, 528, - 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 0, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, - 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 0, 291, - 0, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 529, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 0, 324, 325, 326, 327, 328, 0, 329, - 330, 0, 332, 0, 333, 334, 335, 336, 337, 338, - 0, 339, 340, 0, 0, 341, 342, 343, 0, 0, - 344, 345, 346, 0, 348, 0, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 364, 0, 366, 367, 368, 555, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 0, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 0, 431, 432, - 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 530, 448, 449, 0, 0, - 450, 451, 0, 452, 0, 454, 455, 456, 457, 458, - 0, 459, 460, 461, 0, 0, 462, 463, 464, 465, - 466, 0, 467, 468, 469, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 488, 0, 489, - 0, 491, 492, 493, 494, 495, 496, 497, 0, 0, - 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 527, 0, 553, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, - 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, - 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, - 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, - 152, 153, 154, 155, 156, 0, 157, 158, 159, 160, - 161, 0, 0, 0, 163, 164, 165, 166, 167, 168, - 0, 170, 171, 172, 0, 173, 174, 175, 176, 177, - 178, 0, 0, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, - 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, - 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, - 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, - 0, 235, 0, 0, 0, 238, 239, 528, 0, 242, - 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, - 250, 251, 252, 253, 254, 0, 256, 257, 258, 259, - 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, - 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, - 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, - 286, 287, 288, 0, 0, 289, 0, 291, 0, 0, - 293, 294, 295, 296, 297, 298, 299, 300, 529, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 0, 324, 325, 326, 327, 328, 0, 329, 330, 0, - 332, 0, 333, 334, 335, 336, 337, 338, 0, 339, - 340, 0, 795, 341, 342, 343, 0, 0, 344, 345, - 346, 0, 348, 0, 350, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, - 362, 363, 364, 0, 366, 367, 368, 369, 370, 371, - 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, - 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, - 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, - 399, 400, 0, 401, 402, 0, 404, 405, 406, 407, - 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, - 426, 427, 428, 429, 0, 0, 431, 432, 433, 434, - 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, - 444, 445, 446, 530, 448, 449, 0, 0, 450, 451, - 0, 452, 0, 454, 455, 456, 457, 458, 0, 459, - 460, 461, 0, 0, 462, 463, 464, 465, 466, 0, - 467, 468, 469, 470, 471, 472, 473, 474, 0, 0, - 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, - 483, 484, 485, 486, 487, 488, 0, 489, 0, 491, - 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, - 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, - 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, - 518, 519, 527, 0, 553, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, - 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, - 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, - 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, - 154, 155, 156, 0, 157, 158, 159, 160, 161, 0, - 0, 0, 163, 164, 165, 166, 167, 168, 0, 170, - 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, - 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, - 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, - 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, - 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 0, - 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, - 0, 0, 0, 238, 239, 528, 0, 242, 0, 243, - 0, 244, 245, 246, 247, 0, 248, 249, 250, 251, - 252, 900, 254, 0, 256, 257, 258, 259, 0, 260, - 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, - 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, - 278, 0, 0, 281, 0, 283, 284, 285, 286, 287, - 288, 0, 0, 289, 0, 291, 0, 0, 293, 294, - 295, 296, 297, 298, 299, 300, 529, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 0, 324, - 325, 326, 327, 328, 0, 329, 330, 0, 332, 0, - 333, 334, 335, 336, 337, 338, 0, 339, 340, 0, - 795, 341, 342, 343, 0, 0, 344, 345, 346, 0, - 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, + 358, 359, 360, 361, 26, 27, 28, 0, 362, 363, 364, 0, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, 0, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, - 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, + 420, 33, 0, 421, 422, 423, 424, 425, 426, 427, 428, 429, 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, - 446, 530, 448, 449, 0, 0, 450, 451, 0, 452, + 446, 530, 448, 449, 0, 0, 450, 451, 38, 452, 0, 454, 455, 456, 457, 458, 0, 459, 460, 461, 0, 0, 462, 463, 464, 465, 466, 0, 467, 468, 469, 470, 471, 472, 473, 474, 0, 0, 475, 476, - 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, - 485, 486, 487, 488, 0, 489, 0, 491, 492, 493, - 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, + 477, 40, 478, 479, 480, 481, 0, 482, 483, 484, + 485, 486, 803, 488, 0, 489, 0, 491, 492, 493, + 494, 495, 496, 497, 0, 0, 498, 0, 44, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, - 527, 0, 553, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, - 119, 120, 121, 122, 123, 124, 125, 942, 126, 127, - 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, - 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, - 148, 149, 0, 0, 150, 151, 152, 153, 154, 155, - 156, 0, 157, 158, 159, 160, 161, 0, 0, 0, - 163, 164, 165, 166, 167, 168, 0, 170, 171, 172, - 0, 173, 174, 175, 176, 177, 178, 0, 0, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, - 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, - 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, - 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, - 0, 214, 215, 216, 0, 217, 218, 219, 220, 221, - 222, 223, 224, 225, 226, 227, 228, 0, 229, 0, - 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, - 0, 238, 239, 528, 0, 242, 0, 243, 0, 244, - 245, 246, 247, 0, 248, 249, 250, 251, 252, 253, - 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, - 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, - 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, - 0, 281, 0, 283, 284, 285, 286, 287, 288, 0, - 0, 289, 0, 291, 0, 0, 293, 294, 295, 296, - 297, 298, 299, 300, 529, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 0, 324, 325, 326, - 327, 328, 0, 329, 330, 0, 332, 0, 333, 334, - 335, 336, 337, 338, 0, 339, 340, 0, 0, 341, - 342, 343, 0, 0, 344, 345, 346, 0, 348, 0, - 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, 361, 0, 0, 0, 0, 362, 363, 364, 0, - 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, - 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, - 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, - 402, 0, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, - 0, 421, 422, 423, 424, 425, 426, 427, 428, 429, - 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, - 438, 439, 440, 441, 442, 443, 444, 445, 446, 530, - 448, 449, 0, 0, 450, 451, 0, 452, 0, 454, - 455, 456, 457, 458, 0, 459, 460, 461, 0, 0, - 462, 463, 464, 465, 466, 0, 467, 468, 469, 470, - 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, - 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, - 487, 488, 0, 489, 0, 491, 492, 493, 494, 495, - 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, - 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, - 512, 513, 514, 515, 516, 517, 518, 519, 527, 0, - 553, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, - 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, - 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, - 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, - 0, 0, 150, 151, 152, 153, 154, 155, 156, 0, - 157, 158, 159, 160, 161, 0, 0, 0, 163, 164, - 165, 166, 167, 168, 0, 170, 171, 172, 0, 173, - 174, 175, 176, 177, 178, 0, 0, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, - 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, - 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, - 215, 216, 0, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 1169, 227, 228, 0, 229, 0, 230, 231, - 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, - 239, 528, 0, 242, 0, 243, 0, 244, 245, 246, - 247, 0, 248, 249, 250, 251, 252, 253, 254, 0, - 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, - 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, - 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, - 0, 283, 284, 285, 286, 287, 288, 0, 0, 289, - 0, 291, 0, 0, 293, 294, 295, 296, 297, 298, - 299, 300, 529, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 322, 0, 324, 325, 326, 327, 328, - 0, 329, 330, 0, 332, 0, 333, 334, 335, 336, - 337, 338, 0, 339, 340, 0, 795, 341, 342, 343, - 0, 0, 344, 345, 346, 0, 348, 0, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, - 0, 0, 0, 0, 362, 363, 364, 0, 366, 367, - 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, - 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, - 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 397, 398, 399, 400, 0, 401, 402, 0, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, - 422, 423, 424, 425, 426, 427, 428, 429, 0, 0, - 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, - 440, 441, 442, 443, 444, 445, 446, 530, 448, 449, - 0, 0, 450, 451, 0, 452, 0, 454, 455, 456, - 457, 458, 0, 459, 460, 461, 0, 0, 462, 463, - 464, 465, 466, 0, 467, 468, 469, 470, 471, 472, - 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, - 480, 481, 0, 482, 483, 484, 485, 486, 487, 488, - 0, 489, 0, 491, 492, 493, 494, 495, 496, 497, - 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, - 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, - 514, 515, 516, 517, 518, 519, 527, 1947, 0, 0, - 0, 0, 1948, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, - 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, - 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, - 150, 151, 152, 153, 154, 155, 156, 0, 157, 158, - 159, 160, 161, 0, 0, 0, 163, 164, 165, 166, - 167, 168, 0, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 0, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, - 0, 234, 0, 235, 0, 0, 0, 238, 239, 528, - 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 0, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, - 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 0, 291, - 0, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 529, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 0, 324, 325, 326, 327, 328, 0, 329, - 330, 0, 332, 0, 333, 334, 335, 336, 337, 338, - 0, 339, 340, 0, 0, 341, 342, 343, 0, 0, - 344, 345, 346, 0, 348, 0, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 364, 0, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 0, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 0, 431, 432, - 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 530, 448, 449, 0, 0, - 450, 451, 0, 452, 0, 454, 455, 456, 457, 458, - 0, 459, 460, 461, 0, 0, 462, 463, 464, 465, - 466, 0, 467, 468, 469, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 488, 0, 489, - 0, 491, 492, 493, 494, 495, 496, 497, 0, 0, - 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 527, 0, 553, 0, 0, 0, + 0, 527, 45, 553, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 46, 0, 0, 0, + 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, + 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, + 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, + 147, 148, 149, 0, 0, 150, 151, 152, 153, 154, + 155, 156, 0, 157, 158, 159, 160, 161, 0, 0, + 0, 163, 164, 165, 166, 167, 168, 0, 170, 171, + 172, 0, 173, 174, 175, 176, 177, 178, 0, 0, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, + 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, + 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, + 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 0, 229, + 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, + 0, 0, 238, 239, 528, 0, 242, 0, 243, 0, + 244, 245, 246, 247, 0, 248, 249, 250, 251, 252, + 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, + 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, + 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, + 0, 0, 281, 0, 283, 284, 285, 286, 287, 288, + 0, 0, 289, 0, 291, 0, 0, 293, 294, 295, + 296, 297, 298, 299, 300, 529, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 0, 324, 325, + 326, 327, 328, 0, 329, 330, 0, 332, 0, 333, + 334, 335, 336, 337, 338, 0, 339, 340, 0, 0, + 341, 342, 343, 0, 0, 344, 345, 346, 0, 348, + 0, 350, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 360, 361, 0, 0, 0, 0, 362, 363, 364, + 0, 366, 367, 368, 369, 370, 371, 0, 372, 373, + 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, + 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, + 401, 402, 0, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, + 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, + 429, 0, 0, 431, 432, 433, 434, 0, 435, 436, + 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, + 530, 448, 449, 0, 0, 450, 451, 0, 452, 0, + 454, 455, 456, 457, 458, 0, 459, 460, 461, 0, + 0, 462, 463, 464, 465, 466, 0, 467, 468, 469, + 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, + 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, + 486, 487, 488, 0, 489, 0, 491, 492, 493, 494, + 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, + 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, + 511, 512, 513, 514, 515, 516, 517, 518, 519, 527, + 0, 553, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 990, 0, 0, 118, 119, + 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, + 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, + 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, + 149, 0, 0, 150, 151, 152, 153, 154, 155, 156, + 0, 157, 158, 159, 160, 161, 0, 0, 0, 163, + 164, 165, 166, 167, 168, 0, 170, 171, 172, 0, + 173, 174, 175, 176, 177, 178, 0, 0, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, + 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, + 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, + 214, 215, 216, 0, 217, 218, 219, 220, 221, 222, + 223, 224, 225, 226, 227, 228, 0, 229, 0, 230, + 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, + 238, 239, 528, 0, 242, 0, 243, 0, 244, 245, + 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, + 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, + 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, + 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, + 281, 0, 283, 284, 285, 286, 287, 288, 0, 0, + 289, 0, 291, 0, 0, 293, 294, 295, 296, 297, + 298, 299, 300, 529, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 0, 324, 325, 326, 327, + 328, 0, 329, 330, 0, 332, 0, 333, 334, 335, + 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, + 343, 0, 0, 344, 345, 346, 0, 348, 0, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + 361, 0, 0, 0, 0, 362, 363, 364, 0, 366, + 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, + 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, + 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, + 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, + 0, 404, 405, 406, 407, 408, 409, 410, 411, 412, + 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, + 421, 422, 423, 424, 425, 426, 427, 428, 429, 0, + 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, + 439, 440, 441, 442, 443, 444, 445, 446, 530, 448, + 449, 0, 0, 450, 451, 0, 452, 0, 454, 455, + 456, 457, 458, 0, 459, 460, 461, 0, 0, 462, + 463, 464, 465, 466, 0, 467, 468, 469, 470, 471, + 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, + 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, + 488, 0, 489, 0, 491, 492, 493, 494, 495, 496, + 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, + 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, + 513, 514, 515, 516, 517, 518, 519, 527, 0, 553, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, - 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, - 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, - 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, - 152, 153, 154, 155, 156, 0, 157, 158, 159, 160, - 161, 0, 0, 0, 163, 164, 165, 166, 167, 168, - 0, 170, 171, 172, 0, 173, 174, 175, 176, 177, - 178, 0, 0, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, - 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, - 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, - 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, - 0, 235, 0, 0, 0, 238, 239, 528, 0, 1955, - 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, - 250, 251, 252, 253, 254, 0, 256, 257, 258, 259, - 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, - 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, - 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, - 286, 287, 288, 0, 0, 289, 0, 291, 0, 0, - 293, 294, 1956, 296, 297, 298, 299, 300, 529, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 0, 324, 325, 326, 327, 328, 0, 329, 330, 0, - 332, 0, 333, 334, 335, 336, 337, 338, 0, 339, - 340, 0, 0, 341, 342, 343, 0, 0, 344, 345, - 346, 0, 348, 0, 350, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, - 362, 363, 364, 0, 366, 367, 368, 369, 370, 371, - 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, - 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, - 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, - 399, 400, 0, 401, 402, 0, 404, 405, 406, 407, - 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, - 426, 427, 428, 429, 0, 0, 431, 432, 433, 434, - 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, - 444, 445, 446, 530, 448, 449, 0, 0, 450, 451, - 1957, 452, 0, 454, 1958, 456, 1959, 458, 0, 459, - 460, 461, 0, 0, 462, 463, 464, 465, 466, 0, - 467, 468, 469, 470, 471, 472, 473, 474, 0, 0, - 475, 476, 1960, 0, 478, 479, 480, 481, 0, 482, - 483, 484, 485, 486, 487, 488, 0, 489, 0, 491, - 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, - 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, - 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, - 518, 519, 527, 0, 553, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, - 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, - 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, - 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, - 154, 155, 156, 0, 157, 158, 159, 160, 161, 0, - 0, 0, 163, 164, 165, 166, 167, 168, 0, 170, - 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, - 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, - 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, - 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, - 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 0, - 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, - 0, 0, 0, 238, 239, 528, 0, 242, 0, 243, - 0, 244, 245, 246, 247, 0, 248, 249, 250, 251, - 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, - 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, - 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, - 278, 0, 0, 281, 0, 283, 284, 285, 286, 287, - 288, 0, 0, 289, 0, 291, 0, 0, 293, 294, - 295, 296, 297, 298, 299, 300, 529, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 0, 324, - 325, 326, 327, 328, 0, 329, 330, 0, 332, 0, - 333, 334, 335, 336, 337, 338, 0, 339, 340, 0, - 0, 341, 342, 343, 0, 0, 344, 345, 346, 0, - 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, - 364, 0, 366, 367, 368, 369, 370, 371, 0, 372, - 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, - 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, - 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, - 0, 401, 402, 0, 404, 405, 406, 407, 408, 409, - 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, - 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, - 428, 429, 0, 0, 431, 432, 433, 434, 0, 435, - 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, - 446, 530, 448, 449, 0, 0, 450, 451, 0, 452, - 0, 454, 455, 456, 457, 458, 0, 459, 460, 461, - 0, 0, 462, 463, 464, 465, 466, 0, 467, 468, - 469, 470, 471, 472, 473, 474, 0, 0, 475, 476, - 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, - 485, 486, 487, 488, 0, 489, 0, 491, 492, 493, - 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, - 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, - 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, - 527, 0, 819, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, - 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, - 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, - 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, - 148, 149, 0, 0, 150, 151, 152, 153, 154, 155, - 156, 0, 157, 158, 159, 160, 161, 0, 0, 0, - 163, 164, 165, 166, 167, 168, 0, 170, 171, 172, - 0, 173, 174, 175, 176, 177, 178, 0, 0, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, - 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, - 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, - 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, - 0, 214, 215, 216, 0, 217, 218, 219, 220, 221, - 222, 223, 224, 225, 226, 227, 228, 0, 229, 0, - 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, - 0, 238, 239, 528, 0, 242, 0, 243, 0, 244, - 245, 246, 247, 0, 248, 249, 250, 251, 252, 253, - 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, - 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, - 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, - 0, 281, 0, 283, 284, 285, 286, 287, 288, 0, - 0, 289, 0, 291, 0, 0, 293, 294, 295, 296, - 297, 298, 299, 300, 529, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 0, 324, 325, 326, - 327, 328, 0, 329, 330, 0, 332, 0, 333, 334, - 335, 336, 337, 338, 0, 339, 340, 0, 0, 341, - 342, 343, 0, 0, 344, 345, 346, 0, 348, 0, - 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, 361, 0, 0, 0, 0, 362, 363, 364, 0, - 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, - 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, - 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, - 402, 0, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, - 0, 421, 422, 423, 424, 425, 426, 427, 428, 429, - 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, - 438, 439, 440, 441, 442, 443, 444, 445, 446, 530, - 448, 449, 0, 0, 450, 451, 0, 452, 0, 454, - 455, 456, 457, 458, 0, 459, 460, 461, 0, 0, - 462, 463, 464, 465, 466, 0, 467, 468, 469, 470, - 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, - 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, - 487, 488, 0, 489, 0, 491, 492, 493, 494, 495, - 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, - 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, - 512, 513, 514, 515, 516, 517, 518, 519, 527, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, - 121, 122, 123, 124, 125, 825, 126, 127, 128, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, - 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, - 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, - 0, 0, 150, 151, 152, 153, 154, 155, 156, 0, - 157, 158, 159, 160, 161, 0, 0, 0, 163, 164, - 165, 166, 167, 168, 0, 170, 171, 172, 0, 173, - 174, 175, 176, 177, 178, 0, 0, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, - 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, - 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, - 215, 216, 0, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, - 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, - 239, 528, 0, 826, 0, 243, 0, 244, 245, 246, - 247, 0, 248, 249, 250, 251, 252, 253, 254, 0, - 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, - 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, - 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, - 0, 283, 284, 285, 286, 287, 288, 0, 0, 289, - 0, 291, 0, 0, 293, 294, 827, 296, 297, 298, - 299, 300, 529, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 322, 0, 324, 325, 326, 327, 328, - 0, 329, 330, 0, 332, 0, 333, 334, 335, 336, - 337, 338, 0, 339, 340, 0, 0, 341, 342, 343, - 0, 0, 344, 345, 346, 0, 348, 0, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, - 0, 0, 0, 0, 362, 363, 364, 0, 366, 367, - 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, - 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, - 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 397, 398, 399, 400, 0, 401, 402, 0, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, - 422, 423, 424, 828, 426, 427, 428, 429, 0, 0, - 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, - 440, 441, 442, 443, 444, 445, 446, 530, 448, 449, - 0, 0, 450, 451, 0, 452, 0, 454, 455, 456, - 457, 458, 0, 459, 829, 461, 0, 0, 830, 463, - 464, 465, 466, 0, 467, 468, 469, 470, 471, 472, - 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, - 480, 481, 0, 482, 483, 484, 485, 486, 487, 488, - 0, 489, 0, 491, 492, 493, 494, 495, 496, 497, - 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, - 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, - 514, 515, 516, 517, 518, 519, 527, 0, 553, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, - 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, - 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, - 150, 151, 152, 153, 154, 155, 156, 0, 157, 158, - 159, 160, 161, 0, 0, 0, 163, 164, 165, 166, - 167, 168, 0, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 0, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, - 0, 234, 0, 235, 0, 0, 0, 238, 239, 528, - 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 0, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, - 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 0, 291, - 0, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 529, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 0, 324, 325, 326, 327, 328, 0, 329, - 330, 0, 332, 0, 333, 334, 335, 336, 337, 338, - 0, 339, 340, 0, 0, 341, 342, 343, 0, 0, - 344, 345, 346, 0, 348, 0, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 364, 0, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 383, 384, 385, 862, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 0, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 0, 431, 432, - 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 530, 448, 449, 0, 0, - 450, 451, 0, 452, 0, 454, 455, 456, 457, 458, - 0, 459, 460, 461, 0, 0, 462, 463, 464, 465, - 466, 0, 467, 468, 469, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 488, 0, 489, - 0, 491, 492, 493, 494, 495, 496, 497, 0, 0, - 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 527, 0, 553, 0, 0, 0, + 0, 0, 0, 1475, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, + 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, + 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, + 0, 150, 151, 152, 153, 154, 155, 156, 0, 157, + 158, 159, 160, 161, 0, 0, 0, 163, 164, 165, + 166, 167, 168, 0, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 0, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, + 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, + 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, + 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, + 528, 0, 242, 0, 243, 0, 244, 245, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 0, 256, + 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, + 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, + 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 0, + 291, 0, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 529, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 322, 0, 324, 325, 326, 327, 328, 0, + 329, 330, 0, 332, 0, 333, 334, 335, 336, 337, + 338, 0, 339, 340, 0, 0, 341, 342, 343, 0, + 0, 344, 345, 346, 0, 348, 0, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, + 0, 0, 0, 362, 363, 364, 0, 366, 367, 368, + 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, + 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, + 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 0, 401, 402, 0, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 0, 0, 431, + 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 530, 448, 449, 0, + 0, 450, 451, 0, 452, 0, 454, 455, 456, 457, + 458, 0, 459, 460, 461, 0, 0, 462, 463, 464, + 465, 466, 0, 467, 468, 469, 470, 471, 472, 473, + 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 487, 488, 0, + 489, 0, 491, 492, 493, 494, 495, 496, 497, 0, + 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 527, 0, 553, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, - 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, - 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, - 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, - 152, 153, 154, 155, 156, 0, 157, 158, 159, 160, - 161, 0, 0, 0, 163, 164, 165, 166, 167, 168, - 0, 170, 171, 172, 0, 173, 174, 175, 176, 177, - 178, 0, 0, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, - 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, - 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, - 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, - 0, 235, 0, 0, 0, 238, 239, 528, 0, 242, - 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, - 250, 251, 252, 895, 254, 0, 256, 257, 258, 259, - 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, - 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, - 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, - 286, 287, 288, 0, 0, 289, 0, 291, 0, 0, - 293, 294, 295, 296, 297, 298, 299, 300, 529, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 0, 324, 325, 326, 327, 328, 0, 329, 330, 0, - 332, 0, 333, 334, 335, 336, 337, 338, 0, 339, - 340, 0, 0, 341, 342, 343, 0, 0, 344, 345, - 346, 0, 348, 0, 350, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, - 362, 363, 364, 0, 366, 367, 368, 369, 370, 371, - 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, - 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, - 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, - 399, 400, 0, 401, 402, 0, 404, 405, 406, 407, - 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, - 426, 427, 428, 429, 0, 0, 431, 432, 433, 434, - 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, - 444, 445, 446, 530, 448, 449, 0, 0, 450, 451, - 0, 452, 0, 454, 455, 456, 457, 458, 0, 459, - 460, 461, 0, 0, 462, 463, 464, 465, 466, 0, - 467, 468, 469, 470, 471, 472, 473, 474, 0, 0, - 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, - 483, 484, 485, 486, 487, 488, 0, 489, 0, 491, - 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, - 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, - 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, - 518, 519, 527, 0, 553, 0, 0, 0, 0, 0, + 0, 2214, 0, 0, 118, 119, 120, 121, 122, 123, + 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, + 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, + 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, + 151, 152, 153, 154, 155, 156, 0, 157, 158, 159, + 160, 161, 0, 0, 0, 163, 164, 165, 166, 167, + 168, 0, 170, 171, 172, 0, 173, 174, 175, 176, + 177, 178, 0, 0, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 0, + 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, + 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, + 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, + 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, + 234, 0, 235, 0, 0, 0, 238, 239, 528, 0, + 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, + 249, 250, 251, 252, 253, 254, 0, 256, 257, 258, + 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, + 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, + 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, + 285, 286, 287, 288, 0, 0, 289, 0, 291, 0, + 0, 293, 294, 295, 296, 297, 298, 299, 300, 529, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 0, 324, 325, 326, 327, 328, 0, 329, 330, + 0, 332, 0, 333, 334, 335, 336, 337, 338, 0, + 339, 340, 0, 0, 341, 342, 343, 0, 0, 344, + 345, 346, 0, 348, 0, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, + 0, 362, 363, 364, 0, 366, 367, 368, 369, 370, + 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, + 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, + 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, + 398, 399, 400, 0, 401, 402, 0, 404, 405, 406, + 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, + 425, 426, 427, 428, 429, 0, 0, 431, 432, 433, + 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, + 443, 444, 445, 446, 530, 448, 449, 0, 0, 450, + 451, 0, 452, 0, 454, 455, 456, 457, 458, 0, + 459, 460, 461, 0, 0, 462, 463, 464, 465, 466, + 0, 467, 468, 469, 470, 471, 472, 473, 474, 0, + 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, + 482, 483, 484, 485, 486, 487, 488, 0, 489, 0, + 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, + 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, + 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, + 517, 518, 519, 527, 0, 553, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 2456, + 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, + 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, + 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, + 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, + 153, 154, 155, 156, 0, 157, 158, 159, 160, 161, + 0, 0, 0, 163, 164, 165, 166, 167, 168, 0, + 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, + 0, 0, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, + 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, + 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, + 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, + 235, 0, 0, 0, 238, 239, 528, 0, 242, 0, + 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, + 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, + 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, + 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, + 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, + 287, 288, 0, 0, 289, 0, 291, 0, 0, 293, + 294, 295, 296, 297, 298, 299, 300, 529, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 322, 0, + 324, 325, 326, 327, 328, 0, 329, 330, 0, 332, + 0, 333, 334, 335, 336, 337, 338, 0, 339, 340, + 0, 0, 341, 342, 343, 0, 0, 344, 345, 346, + 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, + 363, 364, 0, 366, 367, 368, 369, 370, 371, 0, + 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, + 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, + 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, + 400, 0, 401, 402, 0, 404, 405, 406, 407, 408, + 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, + 419, 420, 0, 0, 421, 422, 423, 424, 425, 426, + 427, 428, 429, 0, 0, 431, 432, 433, 434, 0, + 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, + 445, 446, 530, 448, 449, 0, 0, 450, 451, 0, + 452, 0, 454, 455, 456, 457, 458, 0, 459, 460, + 461, 0, 0, 462, 463, 464, 465, 466, 0, 467, + 468, 469, 470, 471, 472, 473, 474, 0, 0, 475, + 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, + 484, 485, 486, 487, 488, 0, 489, 0, 491, 492, + 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, + 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, + 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, + 519, 527, 0, 553, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 2588, 0, 0, + 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, + 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, + 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, + 147, 148, 149, 0, 0, 150, 151, 152, 153, 154, + 155, 156, 0, 157, 158, 159, 160, 161, 0, 0, + 0, 163, 164, 165, 166, 167, 168, 0, 170, 171, + 172, 0, 173, 174, 175, 176, 177, 178, 0, 0, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, + 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, + 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, + 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 0, 229, + 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, + 0, 0, 238, 239, 528, 0, 242, 0, 243, 0, + 244, 245, 246, 247, 0, 248, 249, 250, 251, 252, + 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, + 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, + 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, + 0, 0, 281, 0, 283, 284, 285, 286, 287, 288, + 0, 0, 289, 0, 291, 0, 0, 293, 294, 295, + 296, 297, 298, 299, 300, 529, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 0, 324, 325, + 326, 327, 328, 0, 329, 330, 0, 332, 0, 333, + 334, 335, 336, 337, 338, 0, 339, 340, 0, 0, + 341, 342, 343, 0, 0, 344, 345, 346, 0, 348, + 0, 350, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 360, 361, 0, 0, 0, 0, 362, 363, 364, + 0, 366, 367, 368, 369, 370, 371, 0, 372, 373, + 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, + 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, + 401, 402, 0, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, + 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, + 429, 0, 0, 431, 432, 433, 434, 0, 435, 436, + 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, + 530, 448, 449, 0, 0, 450, 451, 0, 452, 0, + 454, 455, 456, 457, 458, 0, 459, 460, 461, 0, + 0, 462, 463, 464, 465, 466, 0, 467, 468, 469, + 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, + 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, + 486, 487, 488, 0, 489, 0, 491, 492, 493, 494, + 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, + 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, + 511, 512, 513, 514, 515, 516, 517, 518, 519, 527, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, - 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, - 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, - 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, - 154, 155, 156, 0, 157, 158, 159, 160, 161, 0, - 0, 0, 163, 164, 165, 166, 167, 168, 0, 170, - 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, - 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, - 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, - 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, - 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 0, - 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, - 0, 0, 0, 238, 239, 528, 0, 242, 0, 243, - 0, 244, 245, 246, 247, 0, 248, 249, 250, 251, - 252, 898, 254, 0, 256, 257, 258, 259, 0, 260, - 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, - 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, - 278, 0, 0, 281, 0, 283, 284, 285, 286, 287, - 288, 0, 0, 289, 0, 291, 0, 0, 293, 294, - 295, 296, 297, 298, 299, 300, 529, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 0, 324, - 325, 326, 327, 328, 0, 329, 330, 0, 332, 0, - 333, 334, 335, 336, 337, 338, 0, 339, 340, 0, - 0, 341, 342, 343, 0, 0, 344, 345, 346, 0, - 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, - 364, 0, 366, 367, 368, 369, 370, 371, 0, 372, - 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, - 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, - 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, - 0, 401, 402, 0, 404, 405, 406, 407, 408, 409, - 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, - 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, - 428, 429, 0, 0, 431, 432, 433, 434, 0, 435, - 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, - 446, 530, 448, 449, 0, 0, 450, 451, 0, 452, - 0, 454, 455, 456, 457, 458, 0, 459, 460, 461, - 0, 0, 462, 463, 464, 465, 466, 0, 467, 468, - 469, 470, 471, 472, 473, 474, 0, 0, 475, 476, - 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, - 485, 486, 487, 488, 0, 489, 0, 491, 492, 493, - 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, - 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, - 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, - 527, 0, 553, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, - 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, - 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, - 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, - 148, 149, 0, 0, 150, 151, 152, 153, 154, 155, - 156, 0, 157, 158, 159, 160, 161, 0, 0, 0, - 163, 164, 165, 166, 167, 168, 0, 170, 171, 172, - 0, 173, 174, 175, 176, 177, 178, 0, 0, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, - 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, - 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, - 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, - 0, 214, 215, 216, 0, 217, 218, 219, 220, 221, - 222, 223, 224, 225, 226, 227, 228, 0, 229, 0, - 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, - 0, 238, 239, 528, 0, 242, 0, 243, 0, 244, - 245, 246, 247, 0, 248, 249, 250, 251, 252, 902, - 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, - 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, - 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, - 0, 281, 0, 283, 284, 285, 286, 287, 288, 0, - 0, 289, 0, 291, 0, 0, 293, 294, 295, 296, - 297, 298, 299, 300, 529, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 0, 324, 325, 326, - 327, 328, 0, 329, 330, 0, 332, 0, 333, 334, - 335, 336, 337, 338, 0, 339, 340, 0, 0, 341, - 342, 343, 0, 0, 344, 345, 346, 0, 348, 0, - 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, 361, 0, 0, 0, 0, 362, 363, 364, 0, - 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, - 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, - 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, - 402, 0, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, - 0, 421, 422, 423, 424, 425, 426, 427, 428, 429, - 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, - 438, 439, 440, 441, 442, 443, 444, 445, 446, 530, - 448, 449, 0, 0, 450, 451, 0, 452, 0, 454, - 455, 456, 457, 458, 0, 459, 460, 461, 0, 0, - 462, 463, 464, 465, 466, 0, 467, 468, 469, 470, - 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, - 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, - 487, 488, 0, 489, 0, 491, 492, 493, 494, 495, - 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, - 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, - 512, 513, 514, 515, 516, 517, 518, 519, 527, 0, - 553, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, - 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, - 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, - 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, - 0, 0, 150, 151, 152, 153, 154, 155, 156, 0, - 157, 158, 159, 160, 161, 0, 0, 0, 163, 164, - 165, 166, 167, 168, 0, 170, 171, 172, 0, 173, - 174, 175, 176, 177, 178, 0, 0, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, - 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, - 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, - 215, 216, 0, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, - 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, - 239, 528, 0, 242, 0, 243, 0, 244, 245, 246, - 247, 0, 248, 249, 250, 251, 252, 930, 254, 0, - 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, - 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, - 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, - 0, 283, 284, 285, 286, 287, 288, 0, 0, 289, - 0, 291, 0, 0, 293, 294, 295, 296, 297, 298, - 299, 300, 529, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 322, 0, 324, 325, 326, 327, 328, - 0, 329, 330, 0, 332, 0, 333, 334, 335, 336, - 337, 338, 0, 339, 340, 0, 0, 341, 342, 343, - 0, 0, 344, 345, 346, 0, 348, 0, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, - 0, 0, 0, 0, 362, 363, 364, 0, 366, 367, - 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, - 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, - 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 397, 398, 399, 400, 0, 401, 402, 0, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, - 422, 423, 424, 425, 426, 427, 428, 429, 0, 0, - 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, - 440, 441, 442, 443, 444, 445, 446, 530, 448, 449, - 0, 0, 450, 451, 0, 452, 0, 454, 455, 456, - 457, 458, 0, 459, 460, 461, 0, 0, 462, 463, - 464, 465, 466, 0, 467, 468, 469, 470, 471, 472, - 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, - 480, 481, 0, 482, 483, 484, 485, 486, 487, 488, - 0, 489, 0, 491, 492, 493, 494, 495, 496, 497, - 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, - 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, - 514, 515, 516, 517, 518, 519, 527, 0, 553, 0, + 0, 0, 0, 0, 0, 3235, 0, 0, 118, 119, + 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, + 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, + 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, + 149, 0, 0, 150, 151, 152, 153, 154, 155, 156, + 0, 157, 158, 159, 160, 161, 0, 0, 0, 163, + 164, 165, 166, 167, 168, 0, 170, 171, 172, 0, + 173, 174, 175, 176, 177, 178, 0, 0, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, + 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, + 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, + 214, 215, 216, 0, 217, 218, 219, 220, 221, 222, + 223, 224, 225, 226, 227, 228, 0, 229, 0, 230, + 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, + 238, 239, 528, 0, 242, 0, 243, 0, 244, 245, + 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, + 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, + 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, + 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, + 281, 0, 283, 284, 285, 286, 287, 288, 0, 0, + 289, 0, 291, 0, 0, 293, 294, 295, 296, 297, + 298, 299, 300, 529, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 0, 324, 325, 326, 327, + 328, 0, 329, 330, 0, 332, 0, 333, 334, 335, + 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, + 343, 0, 0, 344, 345, 346, 0, 348, 0, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + 361, 0, 0, 0, 0, 362, 363, 364, 0, 366, + 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, + 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, + 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, + 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, + 0, 404, 405, 406, 407, 408, 409, 410, 411, 412, + 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, + 421, 422, 423, 424, 425, 426, 427, 428, 429, 0, + 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, + 439, 440, 441, 442, 443, 444, 445, 446, 530, 448, + 449, 0, 0, 450, 451, 0, 452, 0, 454, 455, + 456, 457, 458, 0, 459, 460, 461, 0, 0, 462, + 463, 464, 465, 466, 0, 467, 468, 469, 470, 471, + 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, + 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, + 488, 0, 489, 0, 491, 492, 493, 494, 495, 496, + 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, + 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, + 513, 514, 515, 516, 517, 518, 519, 527, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, - 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, - 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, - 150, 151, 152, 153, 154, 155, 156, 0, 157, 158, - 159, 160, 161, 0, 0, 0, 163, 164, 165, 166, - 167, 168, 0, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 0, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, - 0, 234, 0, 235, 0, 0, 0, 238, 239, 528, - 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, - 248, 249, 250, 251, 252, 958, 254, 0, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, - 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 0, 291, - 0, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 529, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 0, 324, 325, 326, 327, 328, 0, 329, - 330, 0, 332, 0, 333, 334, 335, 336, 337, 338, - 0, 339, 340, 0, 0, 341, 342, 343, 0, 0, - 344, 345, 346, 0, 348, 0, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 364, 0, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 0, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 0, 431, 432, - 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 530, 448, 449, 0, 0, - 450, 451, 0, 452, 0, 454, 455, 456, 457, 458, - 0, 459, 460, 461, 0, 0, 462, 463, 464, 465, - 466, 0, 467, 468, 469, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 488, 0, 489, - 0, 491, 492, 493, 494, 495, 496, 497, 0, 0, - 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 527, 0, 553, 0, 0, 0, + 0, 0, 0, 2071, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, + 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, + 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, + 0, 150, 151, 152, 153, 154, 155, 156, 0, 157, + 158, 159, 160, 161, 0, 0, 0, 163, 164, 165, + 166, 167, 168, 0, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 0, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, + 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, + 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, + 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, + 528, 0, 242, 0, 243, 0, 244, 245, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 0, 256, + 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, + 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, + 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 0, + 291, 0, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 529, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 322, 0, 324, 325, 326, 327, 328, 0, + 329, 330, 0, 332, 0, 333, 334, 335, 336, 337, + 338, 0, 339, 340, 0, 0, 341, 342, 343, 0, + 0, 344, 345, 346, 0, 348, 0, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, + 0, 0, 0, 362, 363, 364, 0, 366, 367, 368, + 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, + 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, + 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 0, 401, 402, 0, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 0, 0, 431, + 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 530, 448, 449, 0, + 0, 450, 451, 0, 452, 0, 454, 455, 456, 457, + 458, 0, 459, 460, 461, 0, 0, 462, 463, 464, + 465, 466, 0, 467, 468, 469, 470, 471, 472, 473, + 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 487, 488, 0, + 489, 0, 491, 492, 493, 494, 495, 496, 497, 0, + 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 527, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, - 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, - 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, - 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, - 152, 153, 154, 155, 156, 0, 157, 158, 159, 160, - 161, 0, 0, 0, 163, 164, 165, 166, 167, 168, - 0, 170, 171, 172, 0, 173, 174, 175, 176, 177, - 178, 0, 0, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, - 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, - 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, - 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, - 0, 235, 0, 0, 0, 238, 239, 528, 0, 242, - 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, - 250, 251, 252, 961, 254, 0, 256, 257, 258, 259, - 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, - 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, - 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, - 286, 287, 288, 0, 0, 289, 0, 291, 0, 0, - 293, 294, 295, 296, 297, 298, 299, 300, 529, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 0, 324, 325, 326, 327, 328, 0, 329, 330, 0, - 332, 0, 333, 334, 335, 336, 337, 338, 0, 339, - 340, 0, 0, 341, 342, 343, 0, 0, 344, 345, - 346, 0, 348, 0, 350, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, - 362, 363, 364, 0, 366, 367, 368, 369, 370, 371, - 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, - 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, - 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, - 399, 400, 0, 401, 402, 0, 404, 405, 406, 407, - 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, - 426, 427, 428, 429, 0, 0, 431, 432, 433, 434, - 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, - 444, 445, 446, 530, 448, 449, 0, 0, 450, 451, - 0, 452, 0, 454, 455, 456, 457, 458, 0, 459, - 460, 461, 0, 0, 462, 463, 464, 465, 466, 0, - 467, 468, 469, 470, 471, 472, 473, 474, 0, 0, - 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, - 483, 484, 485, 486, 487, 488, 0, 489, 0, 491, - 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, - 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, - 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, - 518, 519, 527, 0, 0, 0, 0, 0, 0, 0, + 0, 2174, 0, 0, 118, 119, 120, 121, 122, 123, + 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, + 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, + 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, + 151, 152, 153, 154, 155, 156, 0, 157, 158, 159, + 160, 161, 0, 0, 0, 163, 164, 165, 166, 167, + 168, 0, 170, 171, 172, 0, 173, 174, 175, 176, + 177, 178, 0, 0, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 0, + 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, + 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, + 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, + 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, + 234, 0, 235, 0, 0, 0, 238, 239, 528, 0, + 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, + 249, 250, 251, 252, 253, 254, 0, 256, 257, 258, + 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, + 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, + 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, + 285, 286, 287, 288, 0, 0, 289, 0, 291, 0, + 0, 293, 294, 295, 296, 297, 298, 299, 300, 529, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 0, 324, 325, 326, 327, 328, 0, 329, 330, + 0, 332, 0, 333, 334, 335, 336, 337, 338, 0, + 339, 340, 0, 0, 341, 342, 343, 0, 0, 344, + 345, 346, 0, 348, 0, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, + 0, 362, 363, 364, 0, 366, 367, 368, 369, 370, + 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, + 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, + 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, + 398, 399, 400, 0, 401, 402, 0, 404, 405, 406, + 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, + 425, 426, 427, 428, 429, 0, 0, 431, 432, 433, + 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, + 443, 444, 445, 446, 530, 448, 449, 0, 0, 450, + 451, 0, 452, 0, 454, 455, 456, 457, 458, 0, + 459, 460, 461, 0, 0, 462, 463, 464, 465, 466, + 0, 467, 468, 469, 470, 471, 472, 473, 474, 0, + 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, + 482, 483, 484, 485, 486, 487, 488, 0, 489, 0, + 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, + 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, + 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, + 517, 518, 519, 0, 2915, 1350, 819, 0, 0, 2047, + 1050, 0, 0, 0, 0, 0, 2048, 2049, 0, 3096, + 2050, 2051, 2052, 118, 119, 120, 121, 122, 123, 124, + 125, 560, 126, 127, 128, 561, 562, 563, 2916, 565, + 566, 567, 568, 2917, 130, 131, 570, 132, 133, 134, + 2918, 136, 137, 138, 0, 1488, 2919, 1490, 1491, 577, + 144, 145, 146, 147, 148, 149, 578, 579, 150, 151, + 152, 153, 1492, 1493, 156, 582, 157, 158, 159, 160, + 0, 584, 2920, 586, 2921, 164, 165, 166, 167, 168, + 2922, 170, 171, 172, 589, 173, 174, 175, 176, 177, + 178, 590, 2923, 180, 181, 182, 183, 184, 185, 186, + 187, 188, 189, 1498, 191, 192, 1499, 194, 595, 195, + 596, 196, 197, 198, 199, 200, 201, 597, 598, 202, + 203, 204, 205, 599, 600, 206, 207, 1063, 209, 210, + 601, 211, 212, 213, 602, 214, 215, 216, 603, 217, + 218, 219, 220, 0, 222, 223, 224, 225, 226, 227, + 0, 606, 229, 607, 230, 231, 1500, 233, 609, 234, + 610, 235, 2924, 612, 2925, 238, 239, 2926, 2927, 242, + 616, 243, 617, 0, 0, 246, 247, 620, 248, 249, + 250, 251, 252, 253, 254, 2928, 256, 257, 258, 259, + 622, 260, 261, 262, 263, 264, 265, 266, 623, 267, + 2929, 0, 270, 271, 272, 273, 274, 1506, 1507, 628, + 1508, 630, 278, 2930, 2931, 281, 2932, 283, 284, 285, + 286, 287, 288, 634, 635, 289, 2933, 291, 2934, 638, + 293, 294, 295, 296, 297, 298, 299, 300, 2935, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 320, 321, 1515, + 2936, 1517, 325, 326, 327, 2937, 644, 329, 330, 2938, + 332, 646, 0, 334, 1519, 336, 337, 338, 649, 339, + 340, 650, 651, 2939, 342, 343, 652, 653, 344, 345, + 0, 2940, 348, 2941, 0, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, 361, 658, 659, 660, 661, + 362, 363, 0, 2942, 366, 367, 0, 369, 370, 371, + 665, 372, 373, 374, 375, 376, 377, 666, 378, 379, + 380, 381, 382, 1523, 384, 385, 386, 387, 668, 388, + 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, + 399, 400, 669, 401, 402, 2943, 404, 405, 406, 1525, + 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, + 418, 419, 420, 672, 2944, 421, 422, 423, 424, 425, + 426, 2945, 428, 429, 675, 2946, 431, 432, 1529, 434, + 678, 435, 436, 437, 438, 439, 440, 441, 442, 443, + 444, 445, 446, 2947, 448, 0, 681, 682, 450, 451, + 683, 452, 2948, 454, 455, 456, 457, 458, 685, 459, + 1532, 1533, 688, 689, 462, 463, 0, 465, 0, 692, + 467, 468, 2949, 470, 471, 472, 473, 474, 2950, 695, + 475, 476, 477, 696, 478, 479, 480, 481, 697, 482, + 483, 484, 485, 486, 0, 1536, 700, 489, 2951, 491, + 492, 493, 494, 495, 496, 497, 702, 703, 498, 704, + 705, 499, 500, 501, 502, 503, 504, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 516, 517, + 518, 519, 0, 527, 0, 2053, 2054, 2055, 2047, 2952, + 2953, 2058, 2059, 2060, 2061, 2048, 2049, 0, 0, 2050, + 2051, 2052, 118, 119, 120, 121, 122, 123, 124, 125, + 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, + 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, + 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, + 153, 154, 155, 156, 0, 157, 158, 159, 160, 161, + 0, 0, 0, 163, 164, 165, 166, 167, 168, 0, + 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, + 0, 0, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, + 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, + 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, + 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, + 235, 0, 0, 0, 238, 239, 528, 0, 242, 0, + 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, + 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, + 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, + 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, + 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, + 287, 288, 0, 0, 289, 0, 291, 0, 0, 293, + 294, 295, 296, 297, 298, 299, 300, 529, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 322, 0, + 324, 325, 326, 327, 328, 0, 329, 330, 0, 332, + 0, 333, 334, 335, 336, 337, 338, 0, 339, 340, + 0, 0, 341, 342, 343, 0, 0, 344, 345, 346, + 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, + 363, 364, 0, 366, 367, 368, 369, 370, 371, 0, + 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, + 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, + 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, + 400, 0, 401, 402, 0, 404, 405, 406, 407, 408, + 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, + 419, 420, 0, 0, 421, 422, 423, 424, 425, 426, + 427, 428, 429, 0, 0, 431, 432, 433, 434, 0, + 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, + 445, 446, 530, 448, 449, 0, 0, 450, 451, 0, + 452, 0, 454, 455, 456, 457, 458, 0, 459, 460, + 461, 0, 0, 462, 463, 464, 465, 466, 0, 467, + 468, 469, 470, 471, 472, 473, 474, 0, 0, 475, + 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, + 484, 485, 486, 487, 488, 0, 489, 0, 491, 492, + 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, + 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, + 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, + 519, 0, 0, 0, 2053, 2054, 2055, 0, 2056, 2057, + 2058, 2059, 2060, 2061, 1619, 0, 0, 1620, 0, 0, + 0, 1621, 1622, 1623, 1624, 1625, 1626, 1627, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, - 126, 127, 128, 0, 0, 0, 0, 0, 0, 1003, - 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, - 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, - 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, - 154, 155, 156, 0, 157, 158, 159, 160, 161, 0, - 0, 0, 163, 164, 165, 166, 167, 168, 0, 170, - 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, - 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, - 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, - 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, - 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 0, - 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, - 0, 0, 0, 238, 239, 528, 0, 242, 0, 243, - 0, 244, 245, 246, 247, 0, 248, 249, 250, 251, - 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, - 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, - 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, - 278, 0, 0, 281, 0, 283, 284, 285, 286, 287, - 288, 0, 0, 289, 0, 291, 0, 0, 293, 294, - 295, 296, 297, 298, 299, 300, 529, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 0, 324, - 325, 326, 327, 328, 0, 329, 330, 0, 332, 0, - 333, 334, 335, 336, 337, 338, 0, 339, 340, 0, - 0, 341, 342, 343, 0, 0, 344, 345, 346, 0, - 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, - 364, 0, 366, 367, 368, 369, 370, 371, 0, 372, - 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, - 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, - 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, - 0, 401, 402, 0, 404, 405, 406, 407, 408, 409, - 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, - 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, - 428, 429, 0, 0, 431, 432, 433, 434, 0, 435, - 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, - 446, 530, 448, 449, 0, 0, 450, 451, 0, 452, - 0, 454, 455, 456, 457, 458, 0, 459, 460, 461, - 0, 0, 462, 463, 464, 465, 466, 0, 467, 468, - 469, 470, 471, 472, 473, 474, 0, 0, 475, 476, - 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, - 485, 486, 487, 488, 0, 489, 0, 491, 492, 493, - 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, - 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, - 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, - 527, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, - 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, - 128, 0, 0, 0, 0, 0, 0, 1026, 0, 0, - 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, - 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, - 148, 149, 0, 0, 150, 151, 152, 153, 154, 155, - 156, 0, 157, 158, 159, 160, 161, 0, 0, 0, - 163, 164, 165, 166, 167, 168, 0, 170, 171, 172, - 0, 173, 174, 175, 176, 177, 178, 0, 0, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, - 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, - 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, - 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, - 0, 214, 215, 216, 0, 217, 218, 219, 220, 221, - 222, 223, 224, 225, 226, 227, 228, 0, 229, 0, - 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, - 0, 238, 239, 528, 0, 242, 0, 243, 0, 244, - 245, 246, 247, 0, 248, 249, 250, 251, 252, 253, - 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, - 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, - 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, - 0, 281, 0, 283, 284, 285, 286, 287, 288, 0, - 0, 289, 0, 291, 0, 0, 293, 294, 295, 296, - 297, 298, 299, 300, 529, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 0, 324, 325, 326, - 327, 328, 0, 329, 330, 0, 332, 0, 333, 334, - 335, 336, 337, 338, 0, 339, 340, 0, 0, 341, - 342, 343, 0, 0, 344, 345, 346, 0, 348, 0, - 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, 361, 0, 0, 0, 0, 362, 363, 364, 0, - 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, - 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, - 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, - 402, 0, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, - 0, 421, 422, 423, 424, 425, 426, 427, 428, 429, - 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, - 438, 439, 440, 441, 442, 443, 444, 445, 446, 530, - 448, 449, 0, 0, 450, 451, 0, 452, 0, 454, - 455, 456, 457, 458, 0, 459, 460, 461, 0, 0, - 462, 463, 464, 465, 466, 0, 467, 468, 469, 470, - 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, - 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, - 487, 488, 0, 489, 0, 491, 492, 493, 494, 495, - 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, - 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, - 512, 513, 514, 515, 516, 517, 518, 519, 527, 0, + 0, 0, 1628, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1630, 1619, 0, 0, 1620, 0, 0, 1631, + 1621, 1622, 1623, 1624, 1625, 1626, 1627, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1628, 0, 0, 0, 0, 1632, 721, 0, 0, + 0, 1630, 1619, 0, 0, 1620, 0, 0, 1631, 1621, + 1622, 1623, 1624, 1625, 1626, 1627, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1628, 0, 0, 0, 0, 1632, 0, 0, 0, 0, + 1630, 0, 0, 0, 0, 0, 0, 1631, 0, 1619, + 0, 0, 1620, 0, 722, 0, 1621, 1622, 1623, 1624, + 1625, 1626, 1627, 0, 0, 0, 0, 0, 0, 0, + 723, 0, 0, 0, 1632, 0, 0, 1628, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1630, 1619, 0, + 0, 1620, 0, 1633, 1631, 1621, 1622, 1623, 1624, 1625, + 1626, 1627, 0, 0, 0, 0, 0, 0, 0, 0, + 1634, 0, 0, 0, 0, 1635, 1628, 0, 0, 724, + 0, 1632, 0, 0, 0, 0, 1630, 0, 0, 725, + 0, 0, 1633, 1631, 0, 0, 0, 0, 1636, 1637, + 0, 0, 726, 0, 0, 0, 0, 727, 0, 1634, + 0, 0, 0, 1638, 1635, 0, 0, 0, 0, 0, + 1632, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1633, 0, 0, 0, 0, 728, 1636, 1637, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1634, 0, + 0, 1639, 1638, 1635, 1640, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1641, 0, + 0, 1642, 0, 0, 0, 0, 1636, 1637, 1633, 729, + 0, 0, 0, 730, 0, 0, 0, 0, 0, 0, + 1639, 1638, 0, 1640, 0, 1634, 0, 0, 0, 0, + 1635, 0, 0, 0, 0, 0, 0, 1641, 0, 0, + 1642, 0, 0, 0, 0, 0, 0, 1633, 0, 0, + 0, 0, 0, 1636, 1637, 0, 0, 0, 0, 1639, + 0, 0, 1640, 0, 1634, 0, 0, 0, 1638, 1635, + 0, 0, 0, 0, 0, 0, 1641, 543, 0, 1642, + 0, 0, 0, 731, 0, 0, 0, 0, 0, 0, + 0, 0, 1636, 1637, 0, 0, 0, 0, 732, 0, + 1643, 0, 0, 0, 0, 0, 1639, 1638, 0, 1640, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1641, 0, 0, 1642, 0, 0, 0, + 0, 0, 0, 733, 0, 0, 734, 0, 0, 1643, + 0, 0, 0, 0, 0, 1639, 0, 735, 1640, 0, + 736, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1641, 0, 0, 1642, 0, 0, 737, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1643, 0, + 0, 0, 738, 0, 0, 0, 0, 0, 739, 740, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 741, + 0, 0, 0, 0, 0, 742, 0, 1644, 0, 0, + 1645, 1646, 1647, 0, 1648, 1649, 1650, 1651, 1652, 1653, + 0, 0, 0, 0, 2514, 1643, 0, 0, 0, 0, + 0, 1619, 743, 0, 1620, 0, 0, 0, 1621, 1622, + 1623, 1624, 1625, 1626, 1627, 0, 1644, 0, 0, 1645, + 1646, 1647, 0, 1648, 1649, 1650, 1651, 1652, 1653, 1628, + 0, 0, 0, 2722, 1643, 0, 0, 0, 0, 1630, + 0, 0, 0, 0, 0, 0, 1631, 0, 0, 0, + 0, 0, 0, 0, 0, 1644, 0, 0, 1645, 1646, + 1647, 0, 1648, 1649, 1650, 1651, 1652, 1653, 0, 0, + 0, 0, 2794, 1632, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1619, 0, 0, + 1620, 0, 0, 0, 1621, 1622, 1623, 1624, 1625, 1626, + 1627, 0, 1644, 0, 0, 1645, 1646, 1647, 0, 1648, + 1649, 1650, 1651, 1652, 1653, 1628, 0, 0, 0, 2861, + 0, 0, 0, 0, 0, 1630, 1619, 0, 0, 1620, + 0, 0, 1631, 1621, 1622, 1623, 1624, 1625, 1626, 1627, + 0, 1644, 0, 0, 1645, 1646, 1647, 0, 1648, 1649, + 1650, 1651, 1652, 1653, 1628, 0, 0, 0, 3088, 1632, + 0, 0, 0, 0, 1630, 1619, 0, 0, 1620, 0, + 1633, 1631, 1621, 1622, 1623, 1624, 1625, 1626, 1627, 0, + 0, 0, 0, 0, 0, 0, 0, 1634, 0, 0, + 0, 0, 1635, 1628, 0, 0, 0, 0, 1632, 0, + 0, 0, 0, 1630, 0, 0, 0, 0, 0, 0, + 1631, 0, 0, 0, 0, 1636, 1637, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1638, 0, 0, 0, 0, 0, 0, 1632, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1619, 0, 0, 1620, 0, 1633, 0, 1621, 1622, + 1623, 1624, 1625, 1626, 1627, 0, 0, 0, 1639, 0, + 0, 1640, 0, 1634, 0, 0, 0, 0, 1635, 1628, + 0, 0, 0, 0, 0, 1641, 0, 0, 1642, 1630, + 0, 0, 0, 0, 0, 1633, 1631, 0, 0, 0, + 0, 1636, 1637, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1634, 0, 0, 0, 1638, 1635, 0, 0, + 0, 0, 0, 1632, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1633, 0, 0, 0, 0, 0, + 1636, 1637, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1634, 0, 0, 1639, 1638, 1635, 1640, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1641, 0, 0, 1642, 0, 0, 0, 0, 1636, + 1637, 0, 0, 0, 0, 0, 0, 1643, 0, 0, + 0, 0, 0, 1639, 1638, 0, 1640, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1641, 0, 0, 1642, 0, 0, 0, 0, 0, 0, + 1633, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1639, 0, 0, 1640, 0, 1634, 0, 0, + 0, 0, 1635, 0, 0, 0, 0, 0, 0, 1641, + 0, 0, 1642, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1636, 1637, 0, 0, 0, + 0, 0, 0, 1643, 0, 0, 0, 0, 0, 0, + 1638, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1644, 0, 0, 1645, 1646, 1647, + 0, 1648, 1649, 1650, 1651, 1652, 1653, 0, 0, 0, + 0, 3095, 1643, 0, 0, 0, 0, 0, 1639, 0, + 0, 1640, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1641, 0, 0, 1642, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1643, 0, 0, 0, 0, 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, 1645, 1646, 1647, 0, 1648, 1649, 1650, + 1651, 1652, 1653, 0, 0, 0, 0, 3255, 0, 0, + 0, 0, 0, 0, 1619, 0, 0, 1620, 0, 0, + 0, 1621, 1622, 1623, 1624, 1625, 1626, 1627, 0, 1644, + 0, 0, 1645, 1646, 1647, 0, 1648, 1649, 1650, 1651, + 1652, 1653, 1628, 0, 0, 0, 3277, 1643, 721, 0, + 0, 0, 1630, 1619, 0, 0, 1620, 0, 0, 1631, + 1621, 1622, 1623, 1624, 1625, 1626, 1627, 0, 1644, 0, + 0, 1645, 1646, 1647, 0, 1648, 1649, 1650, 1651, 1652, + 1653, 1628, 0, 0, 0, 3378, 1632, 0, 0, 0, + 0, 1630, 0, 0, 0, 0, 0, 0, 1631, 0, + 1619, 0, 0, 1620, 0, 722, 0, 1621, 1622, 1623, + 1624, 1625, 1626, 1627, 0, 0, 0, 0, 0, 0, + 0, 723, 0, 0, 0, 1632, 0, 0, 1628, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1630, 1619, + 0, 0, 1620, 0, 0, 1631, 1621, 1622, 1623, 1624, + 1625, 1626, 1627, 0, 1644, 0, 0, 1645, 1646, 1647, + 0, 1648, 1649, 1650, 1651, 1652, 1653, 1628, 0, 0, + 724, 3435, 1632, 0, 0, 0, 0, 1630, 1619, 0, + 725, 1620, 0, 1633, 1631, 1621, 1622, 1623, 1624, 1625, + 1626, 1627, 0, 726, 0, 0, 0, 0, 727, 0, + 1634, 0, 0, 0, 0, 1635, 1628, 0, 0, 0, + 0, 1632, 0, 0, 0, 0, 1630, 0, 0, 0, + 0, 0, 1633, 1631, 0, 0, 0, 728, 1636, 1637, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1634, + 0, 0, 0, 1638, 1635, 0, 0, 0, 0, 0, + 1632, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1636, 1637, 1633, + 729, 0, 0, 0, 730, 0, 0, 0, 0, 0, + 0, 1639, 1638, 0, 1640, 0, 1634, 0, 0, 0, + 0, 1635, 0, 0, 0, 0, 0, 0, 1641, 0, + 0, 1642, 0, 0, 0, 0, 0, 0, 1633, 0, + 0, 0, 0, 0, 1636, 1637, 0, 0, 0, 0, + 1639, 0, 0, 1640, 0, 1634, 0, 0, 0, 1638, + 1635, 0, 0, 0, 0, 0, 0, 1641, 0, 0, + 1642, 0, 0, 0, 731, 0, 0, 1633, 0, 0, + 0, 0, 0, 1636, 1637, 0, 0, 0, 0, 732, + 0, 0, 0, 0, 1634, 0, 0, 1639, 1638, 1635, + 1640, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1641, 0, 0, 1642, 0, 0, + 0, 0, 1636, 1637, 733, 0, 0, 734, 0, 0, + 1643, 0, 0, 0, 0, 0, 1639, 1638, 735, 1640, + 0, 736, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1641, 0, 0, 1642, 0, 0, 737, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1643, + 0, 0, 0, 738, 0, 1639, 0, 0, 1640, 0, + 740, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 741, 0, 1641, 0, 0, 1642, 742, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1643, 0, 0, 0, + 0, 0, 0, 743, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1644, 0, 0, + 1645, 1646, 1647, 0, 1648, 1649, 1650, 1651, 1652, 1653, + 0, 0, 0, 0, 3457, 1643, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1644, 0, 0, 1645, + 1646, 1647, 0, 1648, 1649, 1650, 1651, 1652, 1653, 0, + 0, 1808, 0, 0, 1643, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, - 121, 122, 123, 124, 125, 825, 126, 127, 128, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, - 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, - 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, - 0, 0, 150, 151, 152, 153, 154, 155, 156, 0, - 157, 158, 159, 160, 161, 0, 0, 0, 163, 164, - 165, 166, 167, 168, 0, 170, 171, 172, 0, 173, - 174, 175, 176, 177, 178, 0, 0, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, - 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, - 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, - 215, 216, 0, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, - 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, - 239, 528, 0, 242, 0, 243, 0, 244, 245, 246, - 247, 0, 248, 249, 250, 251, 252, 253, 254, 0, - 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, - 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, - 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, - 0, 283, 284, 285, 286, 287, 288, 0, 0, 289, - 0, 291, 0, 0, 293, 294, 295, 296, 297, 298, - 299, 300, 529, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 322, 0, 324, 325, 326, 327, 328, - 0, 329, 330, 0, 332, 0, 333, 334, 335, 336, - 337, 338, 0, 339, 340, 0, 0, 341, 342, 343, - 0, 0, 344, 345, 346, 0, 348, 0, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, - 0, 0, 0, 0, 362, 363, 364, 0, 366, 367, - 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, - 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, - 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 397, 398, 399, 400, 0, 401, 402, 0, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, - 422, 423, 424, 425, 426, 427, 428, 429, 0, 0, - 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, - 440, 441, 442, 443, 444, 445, 446, 530, 448, 449, - 0, 0, 450, 451, 0, 452, 0, 454, 455, 456, - 457, 458, 0, 459, 829, 461, 0, 0, 830, 463, - 464, 465, 466, 0, 467, 468, 469, 470, 471, 472, - 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, - 480, 481, 0, 482, 483, 484, 485, 486, 487, 488, - 0, 489, 0, 491, 492, 493, 494, 495, 496, 497, - 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, - 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, - 514, 515, 516, 517, 518, 519, 527, 0, 553, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1644, 0, 0, 1645, 1646, 1647, 0, + 1648, 1649, 1650, 1651, 1652, 1653, 0, 0, 2815, 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, 1645, 1646, 1647, 0, 1648, + 1649, 1650, 1651, 1652, 1653, 0, 0, 3245, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 559, 0, + 0, 1644, 0, 0, 1645, 1646, 1647, 0, 1648, 1649, + 1650, 1651, 1652, 1653, 0, 0, 3419, 118, 119, 120, + 121, 122, 123, 124, 125, 560, 126, 127, 128, 561, + 562, 563, 564, 565, 566, 567, 568, 569, 130, 131, + 570, 132, 133, 134, 571, 136, 137, 138, 572, 573, + 574, 575, 576, 577, 144, 145, 146, 147, 148, 149, + 578, 579, 150, 151, 152, 153, 580, 581, 156, 582, + 157, 158, 159, 160, 583, 584, 585, 586, 587, 164, + 165, 166, 167, 168, 588, 170, 171, 172, 589, 173, + 174, 175, 176, 177, 178, 590, 591, 180, 181, 182, + 183, 184, 185, 186, 187, 188, 189, 593, 191, 192, + 594, 194, 595, 195, 596, 196, 197, 198, 199, 200, + 201, 597, 598, 202, 203, 204, 205, 599, 600, 206, + 207, 208, 209, 210, 601, 211, 212, 213, 602, 214, + 215, 216, 603, 217, 218, 219, 220, 604, 222, 223, + 224, 225, 226, 227, 605, 606, 229, 607, 230, 231, + 608, 233, 609, 234, 610, 235, 611, 612, 613, 238, + 239, 614, 615, 242, 616, 243, 617, 618, 619, 246, + 247, 620, 248, 249, 250, 251, 252, 253, 254, 621, + 256, 257, 258, 259, 622, 260, 261, 262, 263, 264, + 265, 266, 623, 267, 624, 625, 270, 271, 272, 273, + 274, 626, 627, 628, 629, 630, 278, 631, 632, 281, + 633, 283, 284, 285, 286, 287, 288, 634, 635, 289, + 636, 291, 637, 638, 293, 294, 295, 296, 297, 298, + 299, 300, 639, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 640, 641, 642, 325, 326, 327, 643, + 644, 329, 330, 645, 332, 646, 647, 334, 648, 336, + 337, 338, 649, 339, 340, 650, 651, 341, 342, 343, + 652, 653, 344, 345, 654, 655, 348, 656, 657, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, + 658, 659, 660, 661, 362, 363, 662, 663, 366, 367, + 664, 369, 370, 371, 665, 372, 373, 374, 375, 376, + 377, 666, 378, 379, 380, 381, 382, 667, 384, 385, + 386, 387, 668, 388, 389, 390, 391, 392, 393, 394, + 395, 396, 397, 398, 399, 400, 669, 401, 402, 670, + 404, 405, 406, 671, 408, 409, 410, 411, 412, 413, + 414, 415, 416, 417, 418, 419, 420, 672, 673, 421, + 422, 423, 424, 425, 426, 674, 428, 429, 675, 676, + 431, 432, 677, 434, 678, 435, 436, 437, 438, 439, + 440, 441, 442, 443, 444, 445, 446, 679, 448, 680, + 681, 682, 450, 451, 683, 452, 684, 454, 455, 456, + 457, 458, 685, 459, 686, 687, 688, 689, 462, 463, + 690, 465, 691, 692, 467, 468, 693, 470, 471, 472, + 473, 474, 694, 695, 475, 476, 477, 696, 478, 479, + 480, 481, 697, 482, 483, 484, 485, 486, 698, 699, + 700, 489, 701, 491, 492, 493, 494, 495, 496, 497, + 702, 703, 498, 704, 705, 499, 500, 501, 502, 503, + 504, 706, 707, 708, 709, 710, 711, 712, 713, 714, + 715, 716, 516, 517, 518, 519, 527, 0, 0, 0, + 0, 0, 0, 0, 0, 2082, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, @@ -9241,7 +8565,7 @@ static const yytype_int16 yytable[] = 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, 528, 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, - 248, 249, 250, 251, 252, 1304, 254, 0, 256, 257, + 248, 249, 250, 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, @@ -9272,8 +8596,8 @@ static const yytype_int16 yytable[] = 0, 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 527, 0, 553, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 516, 517, 518, 519, 527, 0, 0, 0, 0, 0, + 0, 0, 0, 2715, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, @@ -9291,7 +8615,7 @@ static const yytype_int16 yytable[] = 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, 528, 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, - 250, 251, 252, 1306, 254, 0, 256, 257, 258, 259, + 250, 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, @@ -9322,301 +8646,709 @@ static const yytype_int16 yytable[] = 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, - 518, 519, 527, 0, 553, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 518, 519, 970, 1350, 819, 0, 0, 0, 1050, 0, + 0, 2718, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, - 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, - 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, + 126, 127, 128, 0, 0, 0, 564, 0, 0, 0, + 0, 569, 130, 131, 0, 132, 133, 134, 571, 136, + 137, 138, 572, 573, 574, 575, 576, 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, - 154, 155, 156, 0, 157, 158, 159, 160, 161, 0, - 0, 0, 163, 164, 165, 166, 167, 168, 0, 170, + 580, 581, 156, 0, 157, 158, 159, 160, 583, 0, + 585, 0, 587, 164, 165, 166, 167, 168, 588, 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, - 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, + 591, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 593, 191, 192, 594, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 0, - 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, - 0, 0, 0, 238, 239, 528, 0, 242, 0, 243, - 0, 244, 245, 246, 247, 0, 248, 249, 250, 251, - 252, 1309, 254, 0, 256, 257, 258, 259, 0, 260, - 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, - 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, - 278, 0, 0, 281, 0, 283, 284, 285, 286, 287, - 288, 0, 0, 289, 0, 291, 0, 0, 293, 294, - 295, 296, 297, 298, 299, 300, 529, 302, 303, 304, + 220, 604, 222, 223, 224, 225, 226, 227, 605, 1351, + 229, 0, 230, 231, 608, 233, 0, 234, 0, 235, + 611, 0, 613, 238, 239, 614, 615, 242, 0, 243, + 0, 618, 619, 246, 247, 0, 248, 249, 250, 251, + 252, 253, 254, 621, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 624, 625, + 270, 271, 272, 273, 274, 626, 627, 0, 629, 0, + 278, 631, 632, 281, 633, 283, 284, 285, 286, 287, + 288, 0, 0, 289, 636, 291, 637, 0, 293, 294, + 295, 296, 297, 298, 299, 300, 639, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 0, 324, - 325, 326, 327, 328, 0, 329, 330, 0, 332, 0, - 333, 334, 335, 336, 337, 338, 0, 339, 340, 0, - 0, 341, 342, 343, 0, 0, 344, 345, 346, 0, - 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, + 315, 316, 317, 318, 319, 320, 321, 640, 641, 642, + 325, 326, 327, 643, 0, 329, 330, 645, 332, 0, + 647, 334, 648, 336, 337, 338, 0, 339, 340, 1352, + 0, 341, 342, 343, 0, 0, 344, 345, 654, 655, + 348, 656, 657, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, - 364, 0, 366, 367, 368, 369, 370, 371, 0, 372, + 662, 663, 366, 367, 664, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, - 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, + 382, 667, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, - 0, 401, 402, 0, 404, 405, 406, 407, 408, 409, + 0, 401, 402, 670, 404, 405, 406, 671, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, - 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, - 428, 429, 0, 0, 431, 432, 433, 434, 0, 435, + 420, 0, 673, 421, 422, 423, 424, 425, 426, 674, + 428, 429, 0, 676, 431, 432, 677, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, - 446, 530, 448, 449, 0, 0, 450, 451, 0, 452, - 0, 454, 455, 456, 457, 458, 0, 459, 460, 461, - 0, 0, 462, 463, 464, 465, 466, 0, 467, 468, - 469, 470, 471, 472, 473, 474, 0, 0, 475, 476, + 446, 679, 448, 680, 0, 0, 450, 451, 0, 452, + 684, 454, 455, 456, 457, 458, 0, 459, 686, 687, + 0, 0, 462, 463, 690, 465, 691, 1353, 467, 468, + 693, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, - 485, 486, 487, 488, 0, 489, 0, 491, 492, 493, + 485, 486, 698, 699, 0, 489, 701, 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, - 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, - 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, - 527, 0, 553, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, - 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, - 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, - 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, - 148, 149, 0, 0, 150, 151, 152, 153, 154, 155, - 156, 0, 157, 158, 159, 160, 161, 0, 0, 0, - 163, 164, 165, 166, 167, 168, 0, 170, 171, 172, - 0, 173, 174, 175, 176, 177, 178, 0, 0, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, - 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, - 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, - 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, - 0, 214, 215, 216, 0, 217, 218, 219, 220, 221, - 222, 223, 224, 225, 226, 227, 228, 0, 229, 0, - 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, - 0, 238, 239, 528, 0, 242, 0, 243, 0, 244, - 245, 246, 247, 0, 248, 249, 250, 251, 252, 1311, - 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, - 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, - 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, - 0, 281, 0, 283, 284, 285, 286, 287, 288, 0, - 0, 289, 0, 291, 0, 0, 293, 294, 295, 296, - 297, 298, 299, 300, 529, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 0, 324, 325, 326, - 327, 328, 0, 329, 330, 0, 332, 0, 333, 334, - 335, 336, 337, 338, 0, 339, 340, 0, 0, 341, - 342, 343, 0, 0, 344, 345, 346, 0, 348, 0, - 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, 361, 0, 0, 0, 0, 362, 363, 364, 0, - 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, - 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, - 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, - 402, 0, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, - 0, 421, 422, 423, 424, 425, 426, 427, 428, 429, - 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, - 438, 439, 440, 441, 442, 443, 444, 445, 446, 530, - 448, 449, 0, 0, 450, 451, 0, 452, 0, 454, - 455, 456, 457, 458, 0, 459, 460, 461, 0, 0, - 462, 463, 464, 465, 466, 0, 467, 468, 469, 470, - 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, - 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, - 487, 488, 0, 489, 0, 491, 492, 493, 494, 495, - 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, - 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, - 512, 513, 514, 515, 516, 517, 518, 519, 527, 0, - 553, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, - 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, - 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, - 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, - 0, 0, 150, 151, 152, 153, 154, 155, 156, 0, - 157, 158, 159, 160, 161, 0, 0, 0, 163, 164, - 165, 166, 167, 168, 0, 170, 171, 172, 0, 173, - 174, 175, 176, 177, 178, 0, 0, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, - 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, - 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, - 215, 216, 0, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, - 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, - 239, 528, 0, 242, 0, 243, 0, 244, 245, 246, - 247, 0, 248, 249, 250, 251, 252, 2237, 254, 0, - 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, - 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, - 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, - 0, 283, 284, 285, 286, 287, 288, 0, 0, 289, - 0, 291, 0, 0, 293, 294, 295, 296, 297, 298, - 299, 300, 529, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 322, 0, 324, 325, 326, 327, 328, - 0, 329, 330, 0, 332, 0, 333, 334, 335, 336, - 337, 338, 0, 339, 340, 0, 0, 341, 342, 343, - 0, 0, 344, 345, 346, 0, 348, 0, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, - 0, 0, 0, 0, 362, 363, 364, 0, 366, 367, - 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, - 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, - 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 397, 398, 399, 400, 0, 401, 402, 0, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, - 422, 423, 424, 425, 426, 427, 428, 429, 0, 0, - 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, - 440, 441, 442, 443, 444, 445, 446, 530, 448, 449, - 0, 0, 450, 451, 0, 452, 0, 454, 455, 456, - 457, 458, 0, 459, 460, 461, 0, 0, 462, 463, - 464, 465, 466, 0, 467, 468, 469, 470, 471, 472, - 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, - 480, 481, 0, 482, 483, 484, 485, 486, 487, 488, - 0, 489, 0, 491, 492, 493, 494, 495, 496, 497, - 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, - 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, - 514, 515, 516, 517, 518, 519, 1477, 0, 0, 0, + 500, 501, 502, 503, 504, 706, 707, 708, 709, 710, + 711, 712, 713, 714, 715, 716, 516, 517, 518, 519, + 0, 0, 1619, 0, 0, 1620, 0, 1354, 1355, 1621, + 1622, 1623, 1624, 1625, 1626, 1627, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 1478, 0, 0, -790, 0, 1479, 130, 131, 0, 132, - 133, 134, 1480, 136, 137, 138, 0, 1481, 1482, 1483, - 1484, 0, 144, 145, 146, 147, 148, 149, 0, 0, - 150, 151, 152, 153, 1485, 1486, 156, 0, 157, 158, - 159, 160, 0, 0, 1487, 0, 1488, 164, 165, 166, - 167, 168, 1489, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 1490, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 1491, 191, 192, 1492, 194, - 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 1061, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 0, 222, 223, 224, 225, - 226, 227, 0, 0, 229, 0, 230, 231, 1493, 233, - 0, 234, 0, 235, 1494, 0, 1495, 238, 239, -790, - 1496, 242, 0, 243, 0, 0, 0, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 1497, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 1498, 0, 270, 271, 272, 273, 274, 1499, - 1500, 0, 1501, 0, 278, 1502, 1503, 281, 1504, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 1505, 291, - 1506, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 1507, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 1508, 1509, 1510, 325, 326, 327, 0, 0, 329, - 330, 1511, 332, 0, 0, 334, 1512, 336, 337, 338, - 0, 339, 340, 0, 0, 341, 342, 343, 0, 0, - 344, 345, 0, 1513, 348, 1514, 0, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 0, 1515, 366, 367, 0, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 1516, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 1517, 404, 405, - 406, 1518, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 1519, 421, 422, 423, - 424, 425, 426, 1520, 428, 429, 0, 1521, 431, 432, - 1522, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 1523, 448, 0, 0, 0, - 450, 451, 0, 452, 1524, 454, 455, 456, 457, 458, - 0, 459, 1525, 1526, 0, 0, 462, 463, 0, 465, - 0, 0, 467, 468, 1527, 470, 471, 472, 473, 474, - 1528, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 0, 1529, 0, 489, - 1530, 491, 492, 493, 494, 495, 496, 497, 0, 0, - 498, 0, 0, 499, 500, 501, 502, 503, 504, 527, - 0, 553, 0, 0, 0, 0, 0, 0, 0, 0, - 516, 517, 518, 519, 0, 0, 0, 0, 118, 119, - 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, - 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, - 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, - 149, 0, 0, 150, 151, 152, 153, 154, 155, 156, - 0, 157, 158, 159, 160, 161, 0, 0, 0, 163, - 164, 165, 166, 167, 168, 0, 170, 171, 172, 0, - 173, 174, 175, 176, 177, 178, 0, 0, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, - 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, - 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, - 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, - 214, 215, 216, 0, 217, 218, 219, 220, 221, 222, - 223, 224, 225, 226, 227, 228, 0, 229, 0, 230, - 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, - 238, 239, 528, 0, 242, 0, 243, 0, 244, 245, - 246, 247, 0, 248, 249, 250, 251, 252, 2983, 254, - 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, - 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, - 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, - 281, 0, 283, 284, 285, 286, 287, 288, 0, 0, - 289, 0, 291, 0, 0, 293, 294, 295, 296, 297, - 298, 299, 300, 529, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, 321, 322, 0, 324, 325, 326, 327, - 328, 0, 329, 330, 0, 332, 0, 333, 334, 335, - 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, - 343, 0, 0, 344, 345, 346, 0, 348, 0, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - 361, 0, 0, 0, 0, 362, 363, 364, 0, 366, - 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, - 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, - 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, - 0, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, - 421, 422, 423, 424, 425, 426, 427, 428, 429, 0, - 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 445, 446, 530, 448, - 449, 0, 0, 450, 451, 0, 452, 0, 454, 455, + 1628, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1630, 1619, 0, 0, 1620, 0, 0, 1631, 1621, 1622, + 1623, 1624, 1625, 1626, 1627, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1628, + 0, 0, 0, 0, 1632, 0, 0, 0, 0, 1630, + 1619, 0, 0, 1620, 0, 0, 1631, 1621, 1622, 1623, + 1624, 1625, 1626, 1627, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1628, 0, + 0, 0, 1901, 1632, 0, 0, 0, 0, 1630, 0, + 0, 0, 0, 0, 0, 1631, 0, 0, 0, 1619, + 0, 0, 1620, 0, 0, 0, 1621, 1622, 1623, 1624, + 1625, 1626, 1627, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1632, 0, 0, 0, 0, 1628, 0, 0, + 0, 1937, 0, 0, 0, 0, 1938, 1630, 0, 0, + 0, 1633, 0, 0, 1631, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1634, 0, + 0, 0, 0, 1635, 0, 0, 0, 0, 0, 3525, + 0, 1632, 0, 0, 0, 0, 0, 0, 0, 0, + 1633, 0, 0, 0, 0, 0, 1636, 1637, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1634, 0, 0, + 0, 1638, 1635, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1633, + 0, 0, 0, 0, 0, 1636, 1637, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1634, 0, 0, 1639, + 1638, 1635, 1640, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1641, 0, 0, 1642, + 0, 0, 0, 0, 1636, 1637, 0, 0, 1633, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1639, 1638, + 0, 1640, 0, 0, 0, 1634, 0, 0, 0, 0, + 1635, 0, 0, 0, 0, 1641, 0, 0, 1642, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1636, 1637, 0, 0, 1639, 0, 0, + 1640, 0, 0, 0, 0, 0, 0, 3526, 1638, 0, + 0, 0, 0, 0, 1641, 0, 0, 1642, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1643, 0, + 0, 0, 0, 0, 0, 0, 1639, 0, 0, 1640, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1641, 0, 1372, 1642, 819, 0, 0, + 0, 0, 1619, 0, 0, 1620, 0, 1643, 0, 1621, + 1622, 1623, 1624, 1625, 1626, 1627, 0, 0, 0, 1908, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1628, 0, 0, 0, 1943, 0, 0, 0, 0, 0, + 1630, 0, 0, 0, 0, 0, 1643, 1631, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1373, 1374, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1632, 1644, 0, 0, 1645, 1646, + 1647, 0, 1648, 1649, 1650, 1651, 1652, 1653, 0, 0, + 0, 0, 0, 0, 0, 1643, 0, 0, 0, 0, + 0, 1375, 1376, 0, 0, 1377, 1378, 0, 0, 0, + 0, 0, 0, 0, 1644, 0, 0, 1645, 1646, 1647, + 0, 1648, 1649, 1650, 1651, 1652, 1653, 0, 0, 0, + 0, 1619, 0, 0, 1620, 0, 0, 0, 1621, 1622, + 1623, 1624, 1625, 1626, 1627, 0, 0, 0, 0, 0, + 0, 0, 0, 1644, 0, 0, 1645, 1646, 1647, 1628, + 1648, 1649, 1650, 1651, 1652, 1653, 0, 0, 0, 1630, + 0, 1633, 0, 0, 0, 0, 1631, 0, 0, 0, + 0, 1379, 1380, 0, 0, 0, 0, 0, 1634, 0, + 0, 0, 0, 1635, 0, 0, 0, 0, 0, 0, + 0, 0, 1644, 1632, 0, 1645, 1646, 1647, 0, 1648, + 1649, 1650, 1651, 1652, 1653, 0, 1636, 1637, 0, 0, + 0, 0, 0, 0, 0, 0, 1619, 0, 0, 1620, + 0, 1638, 0, 1621, 1622, 1623, 1624, 1625, 1626, 1627, + 0, 0, 0, 0, 0, 1381, 1382, 1383, 1384, 1385, + 1386, 1387, 1388, 0, 1628, 1389, 1390, 0, 1950, 0, + 0, 0, 0, 0, 1630, 0, 0, 0, 0, 1639, + 0, 1631, 1640, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1641, 0, 0, 1642, + 0, 0, 0, 0, 0, 1948, 0, 0, 1632, 0, + 1633, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1634, 0, 0, + 0, 0, 1635, 0, 0, 0, 0, 0, 0, 1391, + 1392, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1636, 1637, 0, 0, 0, + 0, 0, 0, 0, 0, 1619, 0, 0, 1620, 0, + 1638, 0, 1621, 1622, 1623, 1624, 1625, 1626, 1627, 0, + 1393, 1394, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1628, 0, 0, 0, 0, 1643, 0, + 0, 0, 0, 1630, 0, 1633, 0, 0, 1639, 0, + 1631, 1640, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1634, 0, 0, 1641, 0, 1635, 1642, 0, + 0, 0, 0, 0, 0, 0, 0, 1632, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1636, 1637, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1638, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1395, 1396, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1397, + 1398, 0, 0, 1639, 0, 1644, 1640, 0, 1645, 1646, + 1647, 0, 1648, 1649, 1650, 1651, 1652, 1653, 0, 0, + 1641, 0, 0, 1642, 2075, 0, 0, 1643, 0, 1619, + 0, 0, 1620, 0, 1633, 0, 1621, 1622, 1623, 1624, + 1625, 1626, 1627, 0, 0, 0, 0, 0, 0, 0, + 0, 1634, 0, 0, 0, 0, 1635, 1628, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1630, 0, 0, + 0, 0, 0, 0, 1631, 0, 0, 0, 0, 1636, + 1637, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1638, 0, 0, 0, 0, 0, + 0, 1632, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1643, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1639, 0, 1644, 1640, 0, 1645, 1646, 1647, + 0, 1648, 1649, 1650, 1651, 1652, 1653, 0, 0, 1641, + 0, 0, 1642, 0, 0, 0, 0, 0, 1619, 0, + 0, 1620, 0, 0, 0, 1621, 1622, 1623, 1624, 1625, + 1626, 1627, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1628, 0, 0, 0, + 2792, 0, 0, 0, 0, 0, 1630, 0, 1633, 0, + 0, 0, 0, 1631, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1634, 0, 0, 0, 0, + 1635, 0, 0, 0, 0, 0, 0, 0, 0, 1644, + 1632, 0, 1645, 1646, 1647, 0, 1648, 1649, 1650, 1651, + 1652, 1653, 0, 1636, 1637, 0, 0, 0, 0, 0, + 0, 1643, 0, 1619, 0, 0, 1620, 0, 1638, 0, + 1621, 1622, 1623, 1624, 1625, 1626, 1627, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1628, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1630, 0, 0, 0, 0, 1639, 0, 1631, 1640, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1373, 1374, 1641, 0, 0, 1642, 0, 0, 0, + 0, 0, 0, 0, 0, 1632, 0, 1633, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1634, 0, 0, 0, 0, 1635, + 0, 0, 1375, 1376, 0, 0, 1377, 1378, 1644, 0, + 0, 1645, 1646, 1647, 0, 1648, 1649, 1650, 1651, 1652, + 1653, 0, 1636, 1637, 0, 0, 0, 0, 0, 0, + 0, 0, 1619, 0, 0, 1620, 0, 1638, 0, 1621, + 1622, 1623, 1624, 1625, 1626, 1627, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1628, 0, 0, 0, 0, 1643, 0, 0, 0, 0, + 1630, 0, 1633, 0, 0, 1639, 0, 1631, 1640, 0, + 0, 0, 1379, 1380, 0, 0, 0, 0, 0, 1634, + 0, 0, 1641, 0, 1635, 1642, 0, 0, 2779, 0, + 0, 0, 0, 0, 1632, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1636, 1637, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1638, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1381, 1382, 1383, 1384, + 1385, 1386, 1387, 1388, 0, 0, 1389, 1390, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1639, 0, 1644, 1640, 0, 1645, 1646, 1647, 0, 1648, + 1649, 1650, 1651, 1652, 1653, 0, 0, 1641, 0, 0, + 1642, 0, 0, 0, 1643, 0, 1619, 0, 0, 1620, + 0, 1633, 0, 1621, 1622, 1623, 1624, 1625, 1626, 1627, + 0, 0, 0, 0, 0, 0, 0, 0, 1634, 0, + 0, 0, 0, 1635, 1628, 0, 0, 0, 0, 0, + 1391, 1392, 0, 0, 1630, 0, 0, 0, 0, 0, + 0, 1631, 0, 0, 0, 0, 1818, 1637, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1638, 0, 0, 0, 0, 0, 0, 1632, 0, + 0, 1393, 1394, 0, 0, 0, 0, 0, 0, 1619, + 0, 0, 1620, 0, 0, 0, 1621, 1622, 0, 1643, + 1625, 1626, 1627, 0, 0, 0, 0, 0, 0, 1639, + 0, 1644, 1640, 0, 1645, 1646, 1647, 1628, 1648, 1649, + 1650, 1651, 1652, 1653, 0, 0, 1641, 1630, 0, 1642, + 0, 0, 0, 0, 1631, 0, 1619, 0, 0, 1620, + 0, 0, 0, 1621, 1622, 0, 0, 1625, 1626, 1627, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1632, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1630, 1633, 1395, 1396, 0, 0, + 0, 1631, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1634, 0, 0, 0, 0, 1635, 0, 0, + 1397, 1398, 0, 0, 0, 0, 1644, 0, 1632, 1645, + 1646, 1647, 0, 1648, 1649, 1650, 1651, 1652, 1653, 0, + 1636, 1637, 0, 0, 0, 0, 0, 0, 1643, 0, + 0, 0, 0, 0, 0, 1638, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1633, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1639, 0, 1634, 1640, 0, 0, 0, + 1635, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1641, 0, 0, 1642, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1636, 1637, 1633, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1638, 0, + 0, 0, 1634, 0, 0, 0, 0, 1635, 0, 0, + 0, 0, 0, 0, 0, 1644, 0, 0, 1645, 1646, + 1647, 0, 1648, 1649, 1650, 1651, 1652, 1653, 0, 0, + 1636, 1637, 0, 0, 0, 0, 1639, 0, 0, 1640, + 0, 0, 0, 0, 0, 1638, 0, 0, 0, 0, + 0, 0, 0, 1641, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1643, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1639, 0, 0, 1640, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1641, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1643, 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, 1645, 1646, 1647, 0, 1648, 1649, 1650, 1651, + 2201, 1653, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1643, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 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, 1645, 1646, 1647, 0, 1648, + 1649, 1650, 1651, 1652, 1653, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 559, 0, 2098, 0, 0, 0, 1644, + 0, 0, 1645, 1646, 1647, 0, 1648, 1649, 1650, 1651, + 1652, 1653, 118, 119, 120, 121, 122, 123, 124, 125, + 560, 126, 127, 128, 561, 562, 563, 564, 565, 566, + 567, 568, 569, 130, 131, 570, 132, 133, 134, 571, + 136, 137, 138, 572, 573, 574, 575, 576, 577, 144, + 145, 146, 147, 148, 149, 578, 579, 150, 151, 152, + 153, 580, 581, 156, 582, 157, 158, 159, 160, 583, + 584, 585, 586, 587, 164, 165, 166, 167, 168, 588, + 170, 171, 172, 589, 173, 174, 175, 176, 177, 178, + 590, 591, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 593, 191, 192, 594, 194, 595, 195, 596, + 196, 197, 198, 199, 200, 201, 597, 598, 202, 203, + 204, 205, 599, 600, 206, 207, 208, 209, 210, 601, + 211, 212, 213, 602, 214, 215, 216, 603, 217, 218, + 219, 220, 604, 222, 223, 224, 225, 226, 227, 605, + 606, 229, 607, 230, 231, 608, 233, 609, 234, 610, + 235, 611, 612, 613, 238, 239, 614, 615, 242, 616, + 243, 617, 618, 619, 246, 247, 620, 248, 249, 250, + 251, 252, 253, 254, 621, 256, 257, 258, 259, 622, + 260, 261, 262, 263, 264, 265, 266, 623, 267, 624, + 625, 270, 271, 272, 273, 274, 626, 627, 628, 629, + 630, 278, 631, 632, 281, 633, 283, 284, 285, 286, + 287, 288, 634, 635, 289, 636, 291, 637, 638, 293, + 294, 295, 296, 297, 298, 299, 300, 639, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 640, 641, + 642, 325, 326, 327, 643, 644, 329, 330, 645, 332, + 646, 647, 334, 648, 336, 337, 338, 649, 339, 340, + 650, 651, 341, 342, 343, 652, 653, 344, 345, 654, + 655, 348, 656, 657, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 360, 361, 658, 659, 660, 661, 362, + 363, 662, 663, 366, 367, 664, 369, 370, 371, 665, + 372, 373, 374, 375, 376, 377, 666, 378, 379, 380, + 381, 382, 667, 384, 385, 386, 387, 668, 388, 389, + 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, + 400, 669, 401, 402, 670, 404, 405, 406, 671, 408, + 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, + 419, 420, 672, 673, 421, 422, 423, 424, 425, 426, + 674, 428, 429, 675, 676, 431, 432, 677, 434, 678, + 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, + 445, 446, 679, 448, 680, 681, 682, 450, 451, 683, + 452, 684, 454, 455, 456, 457, 458, 685, 459, 686, + 687, 688, 689, 462, 463, 690, 465, 691, 692, 467, + 468, 693, 470, 471, 472, 473, 474, 694, 695, 475, + 476, 477, 696, 478, 479, 480, 481, 697, 482, 483, + 484, 485, 486, 698, 699, 700, 489, 701, 491, 492, + 493, 494, 495, 496, 497, 702, 703, 498, 704, 705, + 499, 500, 501, 502, 503, 504, 706, 707, 708, 709, + 710, 711, 712, 713, 714, 715, 716, 516, 517, 518, + 519, 559, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 118, 119, 120, 121, 122, 123, 124, 125, 560, 126, + 127, 128, 561, 562, 563, 564, 565, 566, 567, 568, + 569, 130, 131, 570, 132, 133, 134, 571, 136, 137, + 138, 572, 573, 574, 575, 576, 577, 144, 145, 146, + 147, 148, 149, 578, 579, 150, 151, 152, 153, 580, + 581, 156, 582, 157, 158, 159, 160, 583, 584, 585, + 586, 587, 164, 165, 166, 167, 168, 588, 170, 171, + 172, 589, 173, 174, 175, 176, 177, 178, 590, 591, + 180, 181, 182, 183, 184, 185, 592, 187, 188, 189, + 593, 191, 192, 594, 194, 595, 195, 596, 196, 197, + 198, 199, 200, 201, 597, 598, 202, 203, 204, 205, + 599, 600, 206, 207, 208, 209, 210, 601, 211, 212, + 213, 602, 214, 215, 216, 603, 217, 218, 219, 220, + 604, 222, 223, 224, 225, 226, 227, 605, 606, 229, + 607, 230, 231, 608, 233, 609, 234, 610, 235, 611, + 612, 613, 238, 239, 614, 615, 242, 616, 243, 617, + 618, 619, 246, 247, 620, 248, 249, 250, 251, 252, + 253, 254, 621, 256, 257, 258, 259, 622, 260, 261, + 262, 263, 264, 265, 266, 623, 267, 624, 625, 270, + 271, 272, 273, 274, 626, 627, 628, 629, 630, 278, + 631, 632, 281, 633, 283, 284, 285, 286, 287, 288, + 634, 635, 289, 636, 291, 637, 638, 293, 294, 295, + 296, 297, 298, 299, 300, 639, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 640, 641, 642, 325, + 326, 327, 643, 644, 329, 330, 645, 332, 646, 647, + 334, 648, 336, 337, 338, 649, 339, 340, 650, 651, + 341, 342, 343, 652, 653, 344, 345, 654, 655, 348, + 656, 657, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 360, 361, 658, 659, 660, 661, 362, 363, 662, + 663, 366, 367, 664, 369, 370, 371, 665, 372, 373, + 374, 375, 376, 377, 666, 378, 379, 380, 381, 382, + 667, 384, 385, 386, 387, 668, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 397, 398, 399, 400, 669, + 401, 402, 670, 404, 405, 406, 671, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, + 672, 673, 421, 422, 423, 424, 425, 426, 674, 428, + 429, 675, 676, 431, 432, 677, 434, 678, 435, 436, + 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, + 679, 448, 680, 681, 682, 450, 451, 683, 452, 684, + 454, 455, 456, 457, 458, 685, 459, 686, 687, 688, + 689, 462, 463, 690, 465, 691, 692, 467, 468, 693, + 470, 471, 472, 473, 474, 694, 695, 475, 476, 477, + 696, 478, 479, 480, 481, 697, 482, 483, 484, 485, + 486, 698, 699, 700, 489, 701, 491, 492, 493, 494, + 495, 496, 497, 702, 703, 498, 704, 705, 499, 500, + 501, 502, 503, 504, 706, 707, 708, 709, 710, 711, + 712, 713, 714, 715, 716, 516, 517, 518, 519, 559, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, + 120, 121, 122, 123, 124, 125, 560, 126, 127, 128, + 561, 562, 563, 564, 565, 566, 567, 568, 569, 130, + 131, 570, 132, 133, 134, 571, 136, 137, 138, 572, + 573, 574, 575, 576, 577, 144, 145, 146, 147, 148, + 149, 578, 579, 150, 151, 152, 153, 580, 581, 156, + 582, 157, 158, 159, 160, 583, 584, 585, 586, 587, + 164, 165, 166, 167, 168, 588, 170, 171, 172, 589, + 173, 174, 175, 176, 177, 178, 590, 591, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 593, 191, + 192, 594, 194, 595, 195, 596, 196, 197, 198, 199, + 200, 201, 597, 598, 202, 203, 204, 205, 599, 600, + 206, 207, 208, 209, 210, 601, 211, 212, 213, 602, + 214, 215, 216, 603, 217, 218, 219, 220, 604, 222, + 223, 224, 225, 226, 227, 605, 606, 229, 607, 230, + 231, 608, 233, 609, 234, 610, 235, 611, 612, 613, + 238, 239, 614, 615, 242, 616, 243, 617, 618, 619, + 246, 247, 620, 248, 249, 250, 251, 252, 946, 254, + 621, 256, 257, 258, 259, 622, 260, 261, 262, 263, + 264, 265, 266, 623, 267, 624, 625, 270, 271, 272, + 273, 274, 626, 627, 628, 629, 630, 278, 631, 632, + 281, 633, 283, 284, 285, 286, 287, 288, 634, 635, + 289, 636, 291, 637, 638, 293, 294, 295, 296, 297, + 298, 299, 300, 639, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 640, 641, 642, 325, 326, 327, + 643, 644, 329, 330, 645, 332, 646, 647, 334, 648, + 336, 337, 338, 649, 339, 340, 650, 651, 341, 342, + 343, 652, 653, 344, 345, 654, 655, 348, 656, 657, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + 361, 658, 659, 660, 661, 362, 363, 662, 663, 366, + 367, 664, 369, 370, 371, 665, 372, 373, 374, 375, + 376, 377, 666, 378, 379, 380, 381, 382, 667, 384, + 385, 386, 387, 668, 388, 389, 390, 391, 392, 393, + 394, 395, 396, 397, 398, 399, 400, 669, 401, 402, + 670, 404, 405, 406, 671, 408, 409, 410, 411, 412, + 413, 414, 415, 416, 417, 418, 419, 420, 672, 673, + 421, 422, 423, 424, 425, 426, 674, 428, 429, 675, + 676, 431, 432, 677, 434, 678, 435, 436, 437, 438, + 439, 440, 441, 442, 443, 444, 445, 446, 679, 448, + 680, 681, 682, 450, 451, 683, 452, 684, 454, 455, + 456, 457, 458, 685, 459, 686, 687, 688, 689, 462, + 463, 690, 465, 691, 692, 467, 468, 693, 470, 471, + 472, 473, 474, 694, 695, 475, 476, 477, 696, 478, + 479, 480, 481, 697, 482, 483, 484, 485, 486, 698, + 699, 700, 489, 701, 491, 492, 493, 494, 495, 496, + 497, 702, 703, 498, 704, 705, 499, 500, 501, 502, + 503, 504, 706, 707, 708, 709, 710, 711, 712, 713, + 714, 715, 716, 516, 517, 518, 519, 559, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 560, 126, 127, 128, 561, 562, + 563, 564, 565, 566, 567, 568, 569, 130, 131, 570, + 132, 133, 134, 571, 136, 137, 138, 572, 573, 574, + 575, 576, 577, 144, 145, 146, 147, 148, 149, 578, + 579, 150, 151, 152, 153, 580, 581, 156, 582, 157, + 158, 159, 160, 583, 584, 585, 586, 587, 164, 165, + 166, 167, 168, 588, 170, 171, 172, 589, 173, 174, + 175, 176, 177, 178, 590, 591, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 593, 191, 192, 594, + 194, 595, 195, 596, 196, 197, 198, 199, 200, 201, + 597, 598, 202, 203, 204, 205, 599, 600, 206, 207, + 208, 209, 210, 601, 211, 212, 213, 602, 214, 215, + 216, 603, 217, 218, 219, 220, 604, 222, 223, 224, + 225, 226, 227, 605, 606, 229, 607, 230, 231, 608, + 233, 609, 234, 610, 235, 611, 612, 613, 238, 239, + 614, 615, 242, 616, 243, 617, 618, 619, 246, 247, + 620, 248, 249, 250, 251, 252, 253, 254, 621, 256, + 257, 258, 259, 622, 260, 261, 262, 263, 264, 265, + 266, 623, 267, 624, 625, 270, 271, 272, 273, 274, + 626, 627, 628, 629, 630, 278, 631, 632, 281, 633, + 283, 284, 285, 286, 287, 288, 634, 635, 289, 636, + 291, 637, 638, 293, 294, 295, 296, 297, 298, 299, + 300, 639, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 640, 641, 642, 325, 326, 327, 643, 644, + 329, 330, 645, 332, 646, 647, 334, 648, 336, 337, + 338, 649, 339, 340, 650, 651, 341, 342, 343, 652, + 653, 344, 345, 654, 655, 348, 656, 657, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 658, + 659, 660, 661, 362, 363, 662, 663, 366, 367, 664, + 369, 370, 371, 665, 372, 373, 374, 375, 376, 377, + 666, 378, 379, 380, 381, 382, 667, 384, 385, 386, + 387, 668, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 669, 401, 402, 670, 404, + 405, 406, 671, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 672, 673, 421, 422, + 423, 424, 425, 426, 674, 428, 429, 675, 676, 431, + 432, 677, 434, 678, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 679, 448, 680, 681, + 682, 450, 451, 683, 452, 684, 454, 455, 456, 457, + 458, 685, 459, 686, 687, 688, 689, 462, 463, 690, + 465, 691, 692, 467, 468, 693, 470, 471, 472, 473, + 474, 694, 695, 475, 476, 477, 696, 478, 479, 480, + 481, 697, 482, 483, 484, 485, 486, 698, 699, 700, + 489, 701, 491, 492, 493, 494, 495, 496, 497, 702, + 703, 498, 704, 705, 499, 500, 501, 502, 503, 504, + 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, + 716, 516, 517, 518, 519, 559, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 118, 119, 120, 121, 2250, 123, + 124, 125, 560, 126, 127, 128, 561, 562, 563, 564, + 565, 566, 567, 568, 569, 130, 131, 570, 132, 133, + 134, 571, 136, 137, 138, 572, 573, 574, 575, 576, + 577, 144, 145, 146, 147, 148, 149, 578, 579, 150, + 151, 152, 153, 580, 581, 156, 582, 157, 158, 159, + 160, 583, 584, 585, 586, 587, 164, 165, 166, 167, + 168, 588, 170, 171, 172, 589, 173, 174, 175, 176, + 177, 178, 590, 591, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 593, 191, 192, 594, 194, 595, + 195, 596, 196, 197, 198, 199, 200, 201, 597, 598, + 202, 203, 204, 205, 599, 600, 206, 207, 208, 2251, + 210, 601, 211, 212, 213, 602, 214, 215, 216, 603, + 217, 218, 219, 220, 604, 222, 223, 224, 225, 226, + 227, 605, 606, 229, 607, 230, 231, 608, 233, 609, + 234, 610, 235, 611, 612, 613, 238, 239, 614, 615, + 242, 616, 243, 617, 618, 619, 246, 247, 620, 248, + 249, 250, 251, 252, 253, 254, 621, 256, 257, 258, + 259, 622, 260, 261, 262, 263, 264, 265, 266, 623, + 267, 624, 625, 270, 271, 272, 273, 274, 626, 627, + 628, 629, 630, 278, 631, 632, 281, 633, 283, 284, + 285, 286, 287, 288, 634, 635, 289, 636, 291, 637, + 638, 293, 294, 295, 296, 297, 298, 299, 300, 639, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 640, 641, 642, 325, 326, 327, 643, 644, 329, 330, + 645, 332, 646, 647, 334, 648, 336, 337, 338, 649, + 339, 340, 650, 651, 341, 342, 343, 652, 653, 344, + 345, 654, 655, 348, 656, 657, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, 361, 658, 659, 660, + 661, 362, 363, 662, 663, 366, 367, 664, 369, 370, + 371, 665, 372, 373, 374, 375, 376, 377, 666, 378, + 379, 380, 381, 382, 667, 384, 385, 386, 387, 668, + 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, + 398, 399, 400, 669, 401, 402, 670, 404, 405, 406, + 671, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 417, 418, 419, 420, 672, 673, 421, 422, 423, 424, + 425, 2252, 674, 428, 429, 675, 676, 431, 432, 677, + 434, 678, 435, 436, 437, 438, 439, 440, 441, 442, + 443, 444, 445, 446, 679, 448, 680, 681, 682, 450, + 451, 683, 452, 684, 454, 455, 456, 457, 458, 685, + 459, 686, 687, 688, 689, 462, 463, 690, 465, 691, + 692, 467, 468, 693, 470, 471, 472, 473, 474, 694, + 695, 475, 476, 477, 696, 478, 479, 480, 481, 697, + 482, 483, 484, 485, 486, 698, 699, 700, 489, 701, + 491, 492, 493, 494, 495, 496, 497, 702, 703, 498, + 704, 705, 499, 500, 501, 502, 503, 504, 706, 707, + 708, 709, 710, 711, 712, 713, 714, 715, 716, 516, + 517, 518, 519, 970, 0, 819, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, + 0, 126, 127, 128, 0, 0, 0, 564, 0, 0, + 0, 0, 569, 130, 131, 0, 132, 133, 134, 571, + 136, 137, 138, 572, 573, 574, 575, 576, 0, 144, + 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, + 153, 580, 581, 156, 0, 157, 158, 159, 160, 583, + 0, 585, 0, 587, 164, 165, 166, 167, 168, 588, + 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, + 0, 591, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 593, 191, 192, 594, 194, 0, 195, 0, + 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, + 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, + 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, + 219, 220, 604, 222, 223, 224, 225, 226, 227, 605, + 1351, 229, 0, 230, 231, 608, 233, 0, 234, 0, + 235, 611, 0, 613, 238, 239, 614, 615, 242, 0, + 243, 0, 618, 619, 246, 247, 0, 248, 249, 250, + 251, 252, 253, 254, 621, 256, 257, 258, 259, 0, + 260, 261, 262, 263, 264, 265, 266, 0, 267, 624, + 625, 270, 271, 272, 273, 274, 626, 627, 0, 629, + 0, 278, 631, 632, 281, 633, 283, 284, 285, 286, + 287, 288, 0, 0, 289, 636, 291, 637, 0, 293, + 294, 295, 296, 297, 298, 299, 300, 639, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 640, 641, + 642, 325, 326, 327, 643, 0, 329, 330, 645, 332, + 0, 647, 334, 648, 336, 337, 338, 0, 339, 340, + 1352, 0, 341, 342, 343, 0, 0, 344, 345, 654, + 655, 348, 656, 657, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, + 363, 662, 663, 366, 367, 664, 369, 370, 371, 0, + 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, + 381, 382, 667, 384, 385, 386, 387, 0, 388, 389, + 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, + 400, 0, 401, 402, 670, 404, 405, 406, 671, 408, + 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, + 419, 420, 0, 673, 421, 422, 423, 424, 425, 426, + 674, 428, 429, 0, 676, 431, 432, 677, 434, 0, + 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, + 445, 446, 679, 448, 680, 0, 0, 450, 451, 0, + 452, 684, 454, 455, 456, 457, 458, 0, 459, 686, + 687, 0, 0, 462, 463, 690, 465, 691, 1353, 467, + 468, 693, 470, 471, 472, 473, 474, 0, 0, 475, + 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, + 484, 485, 486, 698, 699, 0, 489, 701, 491, 492, + 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, + 499, 500, 501, 502, 503, 504, 706, 707, 708, 709, + 710, 711, 712, 713, 714, 715, 716, 516, 517, 518, + 519, 970, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, + 127, 128, 3, 4, 0, 564, 0, 0, 0, 0, + 569, 130, 131, 0, 132, 133, 134, 571, 136, 137, + 138, 572, 573, 574, 575, 576, 0, 144, 145, 146, + 147, 148, 149, 0, 0, 150, 151, 152, 153, 580, + 581, 156, 0, 157, 158, 159, 160, 583, 0, 585, + 0, 587, 164, 165, 166, 167, 168, 588, 170, 171, + 172, 0, 173, 174, 175, 176, 177, 178, 0, 591, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 593, 191, 192, 594, 194, 0, 195, 0, 196, 197, + 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, + 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, + 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, + 604, 222, 223, 224, 225, 226, 227, 605, 0, 229, + 0, 230, 231, 608, 233, 0, 234, 0, 235, 611, + 0, 613, 238, 239, 614, 615, 242, 0, 243, 0, + 618, 619, 246, 247, 0, 248, 249, 250, 251, 252, + 253, 254, 621, 256, 257, 258, 259, 0, 260, 261, + 262, 263, 264, 265, 266, 0, 267, 624, 625, 270, + 271, 272, 273, 274, 626, 627, 0, 629, 0, 278, + 631, 632, 281, 633, 283, 284, 285, 286, 287, 288, + 0, 0, 289, 636, 291, 637, 0, 293, 294, 295, + 296, 297, 298, 299, 300, 639, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 640, 641, 642, 325, + 326, 327, 643, 0, 329, 330, 645, 332, 0, 647, + 334, 648, 336, 337, 338, 0, 339, 340, 0, 0, + 341, 342, 343, 0, 0, 344, 345, 654, 655, 348, + 656, 657, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 360, 361, 0, 0, 0, 0, 362, 363, 662, + 663, 366, 367, 664, 369, 370, 371, 0, 372, 373, + 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, + 667, 384, 385, 386, 387, 0, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, + 401, 402, 670, 404, 405, 406, 671, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, + 0, 673, 421, 422, 423, 424, 425, 426, 674, 428, + 429, 0, 676, 431, 432, 677, 434, 0, 435, 436, + 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, + 679, 448, 680, 0, 0, 450, 451, 0, 452, 684, + 454, 455, 456, 457, 458, 0, 459, 686, 687, 0, + 0, 462, 463, 690, 465, 691, 0, 467, 468, 693, + 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, + 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, + 486, 698, 699, 0, 489, 701, 491, 492, 493, 494, + 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, + 501, 502, 503, 504, 706, 707, 708, 709, 710, 711, + 712, 713, 714, 715, 716, 516, 517, 518, 519, 117, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, + 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, + 0, 0, 0, 0, 0, 0, 0, 0, 129, 130, + 131, 0, 132, 133, 134, 135, 136, 137, 138, 139, + 140, 141, 142, 143, 0, 144, 145, 146, 147, 148, + 149, 0, 789, 150, 151, 152, 153, 154, 155, 156, + 0, 157, 158, 159, 160, 790, 0, 791, 0, 163, + 164, 165, 166, 167, 168, 169, 170, 171, 172, 0, + 173, 174, 175, 176, 177, 178, 0, 179, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, + 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, + 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, + 214, 215, 216, 0, 217, 218, 219, 220, 221, 222, + 223, 224, 225, 226, 227, 792, 0, 229, 0, 230, + 231, 232, 233, 0, 234, 0, 235, 236, 0, 237, + 238, 239, 240, 241, 242, 0, 243, 0, 244, 245, + 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 0, 260, 261, 262, 263, + 264, 265, 266, 0, 267, 268, 269, 270, 271, 272, + 273, 274, 275, 276, 0, 277, 0, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 0, 0, + 289, 290, 291, 292, 0, 293, 294, 295, 296, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, 0, 329, 330, 331, 332, 0, 794, 334, 335, + 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, + 343, 0, 0, 344, 345, 346, 347, 348, 349, 796, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + 361, 0, 0, 0, 0, 362, 363, 797, 365, 366, + 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, + 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, + 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, + 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, + 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, + 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, + 421, 422, 423, 424, 425, 426, 427, 428, 429, 0, + 430, 431, 432, 433, 434, 0, 435, 436, 437, 438, + 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, + 799, 0, 0, 450, 451, 0, 452, 453, 454, 455, 456, 457, 458, 0, 459, 460, 461, 0, 0, 462, - 463, 464, 465, 466, 0, 467, 468, 469, 470, 471, + 463, 800, 465, 801, 0, 467, 468, 802, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, - 488, 0, 489, 0, 491, 492, 493, 494, 495, 496, + 488, 0, 489, 490, 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 516, 517, 518, 519, 527, 0, 0, + 513, 514, 515, 516, 517, 518, 519, 117, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, - 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, + 0, 0, 0, 0, 0, 0, 129, 130, 131, 0, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, 154, 155, 156, 0, 157, - 158, 159, 160, 161, 0, 0, 0, 163, 164, 165, - 166, 167, 168, 0, 170, 171, 172, 0, 173, 174, - 175, 176, 177, 178, 0, 0, 180, 181, 182, 183, + 158, 159, 160, 161, 0, 162, 0, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, - 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, - 528, 0, 242, 0, 243, 0, 244, 245, 246, 247, - 0, 248, 249, 250, 251, 252, 253, 254, 0, 256, + 233, 0, 234, 0, 235, 236, 0, 237, 238, 239, + 240, 241, 242, 0, 243, 0, 244, 245, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, - 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, - 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, - 283, 284, 285, 286, 287, 288, 0, 0, 289, 0, - 291, 0, 0, 293, 294, 295, 296, 297, 298, 299, - 300, 529, 302, 303, 304, 305, 306, 307, 308, 309, + 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 0, 277, 0, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 290, + 291, 292, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 0, 324, 325, 326, 327, 328, 0, - 329, 330, 0, 332, 0, 333, 334, 335, 336, 337, + 320, 321, 322, 323, 324, 325, 326, 327, 328, 0, + 329, 330, 331, 332, 0, 333, 334, 335, 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, 343, 0, - 0, 344, 345, 346, 0, 348, 0, 350, 351, 352, + 0, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, - 0, 0, 0, 362, 363, 364, 0, 366, 367, 368, + 0, 0, 0, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, - 396, 397, 398, 399, 400, 0, 401, 402, 0, 404, + 396, 397, 398, 399, 400, 0, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, - 423, 424, 425, 426, 427, 428, 429, 0, 0, 431, + 423, 424, 425, 426, 427, 428, 429, 0, 430, 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, - 441, 442, 443, 444, 445, 446, 530, 448, 449, 0, - 0, 450, 451, 0, 452, 0, 454, 455, 456, 457, + 441, 442, 443, 444, 445, 446, 447, 448, 449, 0, + 0, 450, 451, 0, 452, 453, 454, 455, 456, 457, 458, 0, 459, 460, 461, 0, 0, 462, 463, 464, 465, 466, 0, 467, 468, 469, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, 488, 0, - 489, 0, 491, 492, 493, 494, 495, 496, 497, 0, + 489, 490, 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 527, 0, 0, 0, 0, @@ -9626,9 +9358,9 @@ static const yytype_int16 yytable[] = 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, - 151, 152, 153, 154, 155, 156, 0, 157, 158, 159, - 160, 161, 0, 0, 0, 163, 164, 165, 166, 167, - 168, 0, 170, 171, 172, 0, 173, 174, 175, 176, + 151, 152, 153, 154, 155, 156, 1751, 157, 158, 159, + 160, 161, 0, 0, 1752, 163, 164, 165, 166, 167, + 168, 0, 170, 171, 172, 1753, 173, 174, 175, 176, 177, 178, 0, 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, @@ -9636,14 +9368,14 @@ static const yytype_int16 yytable[] = 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, - 234, 0, 235, 0, 0, 0, 238, 239, 528, 0, - 840, 0, 243, 0, 244, 245, 246, 247, 0, 248, - 249, 250, 251, 252, 253, 254, 0, 256, 257, 258, + 234, 1754, 235, 0, 0, 0, 238, 239, 528, 0, + 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, + 249, 250, 251, 252, 1755, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, 287, 288, 0, 0, 289, 0, 291, 0, - 0, 293, 294, 841, 296, 297, 298, 299, 300, 529, + 0, 293, 294, 295, 296, 297, 298, 299, 300, 529, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 0, 324, 325, 326, 327, 328, 0, 329, 330, @@ -9652,19 +9384,19 @@ static const yytype_int16 yytable[] = 345, 346, 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, 364, 0, 366, 367, 368, 369, 370, - 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, + 371, 1756, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, 0, 404, 405, 406, - 407, 408, 409, 410, 411, 842, 413, 414, 415, 416, + 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, - 843, 426, 427, 428, 429, 0, 0, 431, 432, 433, + 425, 426, 427, 428, 429, 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 530, 448, 449, 0, 0, 450, 451, 0, 452, 0, 454, 455, 456, 457, 458, 0, - 459, 844, 461, 0, 0, 462, 463, 464, 465, 466, + 459, 460, 461, 0, 0, 462, 463, 464, 465, 466, 0, 467, 468, 469, 470, 471, 472, 473, 474, 0, - 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, + 1757, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, 488, 0, 489, 0, 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, @@ -9676,23 +9408,23 @@ static const yytype_int16 yytable[] = 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, - 153, 154, 155, 156, 0, 157, 158, 159, 160, 161, + 153, 154, 155, 156, 1751, 157, 158, 159, 160, 161, 0, 0, 0, 163, 164, 165, 166, 167, 168, 0, - 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, + 170, 171, 172, 1753, 173, 174, 175, 176, 177, 178, 0, 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, - 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, + 0, 229, 0, 230, 231, 232, 233, 0, 234, 1754, 235, 0, 0, 0, 238, 239, 528, 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, - 251, 252, 954, 254, 0, 256, 257, 258, 259, 0, + 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, - 287, 288, 0, 0, 289, 0, 291, 0, 0, 293, + 287, 288, 0, 0, 289, 0, 291, 2335, 0, 293, 294, 295, 296, 297, 298, 299, 300, 529, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 0, @@ -9701,7 +9433,7 @@ static const yytype_int16 yytable[] = 0, 0, 341, 342, 343, 0, 0, 344, 345, 346, 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, - 363, 364, 0, 366, 367, 368, 369, 370, 371, 0, + 363, 364, 0, 366, 367, 368, 369, 370, 371, 1756, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, @@ -9713,16 +9445,16 @@ static const yytype_int16 yytable[] = 445, 446, 530, 448, 449, 0, 0, 450, 451, 0, 452, 0, 454, 455, 456, 457, 458, 0, 459, 460, 461, 0, 0, 462, 463, 464, 465, 466, 0, 467, - 468, 469, 470, 471, 472, 473, 474, 0, 0, 475, + 468, 469, 470, 471, 472, 473, 474, 0, 1757, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, 488, 0, 489, 0, 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, - 519, 527, 0, 0, 0, 0, 0, 0, 0, 0, + 519, 527, 0, 553, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, - 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, + 127, 128, 3, 4, 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, 154, @@ -9756,12 +9488,12 @@ static const yytype_int16 yytable[] = 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, 0, 404, 405, 406, 407, 408, 409, 410, - 411, 842, 413, 414, 415, 416, 417, 418, 419, 420, + 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, 429, 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 530, 448, 449, 0, 0, 450, 451, 0, 452, 0, - 454, 455, 456, 457, 458, 0, 459, 844, 461, 0, + 454, 455, 456, 457, 458, 0, 459, 460, 461, 0, 0, 462, 463, 464, 465, 466, 0, 467, 468, 469, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, @@ -9769,9 +9501,9 @@ static const yytype_int16 yytable[] = 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 527, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 553, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, - 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, + 120, 121, 122, 123, 124, 125, 554, 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, @@ -9787,7 +9519,7 @@ static const yytype_int16 yytable[] = 223, 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, 528, 0, 242, 0, 243, 0, 244, 245, - 246, 247, 0, 248, 249, 250, 251, 252, 1313, 254, + 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, @@ -9801,7 +9533,7 @@ static const yytype_int16 yytable[] = 343, 0, 0, 344, 345, 346, 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, 364, 0, 366, - 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, + 367, 368, 555, 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, @@ -9818,7 +9550,7 @@ static const yytype_int16 yytable[] = 488, 0, 489, 0, 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 516, 517, 518, 519, 527, 0, 0, + 513, 514, 515, 516, 517, 518, 519, 527, 0, 553, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, @@ -9837,7 +9569,7 @@ static const yytype_int16 yytable[] = 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, 528, 0, 242, 0, 243, 0, 244, 245, 246, 247, - 0, 248, 249, 250, 251, 252, 1324, 254, 0, 256, + 0, 248, 249, 250, 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, @@ -9847,7 +9579,7 @@ static const yytype_int16 yytable[] = 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 0, 324, 325, 326, 327, 328, 0, 329, 330, 0, 332, 0, 333, 334, 335, 336, 337, - 338, 0, 339, 340, 0, 0, 341, 342, 343, 0, + 338, 0, 339, 340, 0, 795, 341, 342, 343, 0, 0, 344, 345, 346, 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, 364, 0, 366, 367, 368, @@ -9868,11 +9600,11 @@ static const yytype_int16 yytable[] = 489, 0, 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, - 515, 516, 517, 518, 519, 527, 0, 0, 0, 0, + 515, 516, 517, 518, 519, 527, 0, 553, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, - 0, 0, 1672, 0, 0, 130, 131, 0, 132, 133, + 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, 154, 155, 156, 0, 157, 158, 159, @@ -9887,7 +9619,7 @@ static const yytype_int16 yytable[] = 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, 528, 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, - 249, 250, 251, 252, 253, 254, 0, 256, 257, 258, + 249, 250, 251, 252, 900, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, @@ -9897,7 +9629,7 @@ static const yytype_int16 yytable[] = 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 0, 324, 325, 326, 327, 328, 0, 329, 330, 0, 332, 0, 333, 334, 335, 336, 337, 338, 0, - 339, 340, 0, 0, 341, 342, 343, 0, 0, 344, + 339, 340, 0, 795, 341, 342, 343, 0, 0, 344, 345, 346, 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, 364, 0, 366, 367, 368, 369, 370, @@ -9907,7 +9639,7 @@ static const yytype_int16 yytable[] = 398, 399, 400, 0, 401, 402, 0, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, - 425, 0, 427, 428, 429, 0, 0, 431, 432, 433, + 425, 426, 427, 428, 429, 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 530, 448, 449, 0, 0, 450, 451, 0, 452, 0, 454, 455, 456, 457, 458, 0, @@ -9918,10 +9650,10 @@ static const yytype_int16 yytable[] = 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, - 517, 518, 519, 527, 0, 0, 0, 0, 0, 0, + 517, 518, 519, 527, 0, 553, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, - 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, + 944, 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, @@ -9937,7 +9669,7 @@ static const yytype_int16 yytable[] = 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, 528, 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, - 251, 252, 1852, 254, 0, 256, 257, 258, 259, 0, + 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, @@ -9968,7 +9700,7 @@ static const yytype_int16 yytable[] = 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, - 519, 527, 0, 0, 0, 0, 0, 0, 0, 0, + 519, 527, 0, 553, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, @@ -9983,11 +9715,11 @@ static const yytype_int16 yytable[] = 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 227, 228, 0, 229, + 221, 222, 223, 224, 225, 1171, 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, 528, 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, 251, 252, - 2224, 254, 0, 256, 257, 258, 259, 0, 260, 261, + 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, 287, 288, @@ -9996,7 +9728,7 @@ static const yytype_int16 yytable[] = 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 0, 324, 325, 326, 327, 328, 0, 329, 330, 0, 332, 0, 333, - 334, 335, 336, 337, 338, 0, 339, 340, 0, 0, + 334, 335, 336, 337, 338, 0, 339, 340, 0, 795, 341, 342, 343, 0, 0, 344, 345, 346, 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, 364, @@ -10018,7 +9750,7 @@ static const yytype_int16 yytable[] = 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 527, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1954, 0, 0, 0, 0, 1955, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, @@ -10036,7 +9768,7 @@ static const yytype_int16 yytable[] = 223, 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, 528, 0, 242, 0, 243, 0, 244, 245, - 246, 247, 0, 248, 249, 250, 251, 252, 2239, 254, + 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, @@ -10067,5549 +9799,6086 @@ static const yytype_int16 yytable[] = 488, 0, 489, 0, 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 516, 517, 518, 519, 1477, 0, 0, + 513, 514, 515, 516, 517, 518, 519, 527, 0, 553, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, - 0, 1478, 0, 0, 0, 0, 1479, 130, 131, 0, - 132, 133, 134, 1480, 136, 137, 138, 0, 1481, 1482, - 1483, 1484, 0, 144, 145, 146, 147, 148, 149, 0, - 0, 150, 151, 152, 153, 1485, 1486, 156, 0, 157, - 158, 159, 160, 0, 0, 1487, 0, 1488, 164, 165, - 166, 167, 168, 1489, 170, 171, 172, 0, 173, 174, - 175, 176, 177, 178, 0, 1490, 180, 181, 182, 183, - 184, 185, 186, 187, 188, 189, 1491, 191, 192, 1492, + 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, + 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, + 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, + 0, 150, 151, 152, 153, 154, 155, 156, 0, 157, + 158, 159, 160, 161, 0, 0, 0, 163, 164, 165, + 166, 167, 168, 0, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 0, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, - 1061, 209, 210, 0, 211, 212, 213, 0, 214, 215, - 216, 0, 217, 218, 219, 220, 0, 222, 223, 224, - 225, 226, 227, 0, 0, 229, 0, 230, 231, 1493, - 233, 0, 234, 0, 235, 1494, 0, 1495, 238, 239, - 0, 1496, 242, 0, 243, 0, 0, 0, 246, 247, - 0, 248, 249, 250, 251, 252, 253, 254, 1497, 256, + 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, + 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, + 528, 0, 1962, 0, 243, 0, 244, 245, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, - 266, 0, 267, 1498, 0, 270, 271, 272, 273, 274, - 1499, 1500, 0, 1501, 0, 278, 1502, 1503, 281, 1504, - 283, 284, 285, 286, 287, 288, 0, 0, 289, 1505, - 291, 1506, 0, 293, 294, 295, 296, 297, 298, 299, - 300, 1507, 302, 303, 304, 305, 306, 307, 308, 309, + 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, + 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 0, + 291, 0, 0, 293, 294, 1963, 296, 297, 298, 299, + 300, 529, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 1508, 1509, 1510, 325, 326, 327, 0, 0, - 329, 330, 1511, 332, 0, 0, 334, 1512, 336, 337, + 320, 321, 322, 0, 324, 325, 326, 327, 328, 0, + 329, 330, 0, 332, 0, 333, 334, 335, 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, 343, 0, - 0, 344, 345, 0, 1513, 348, 1514, 0, 351, 352, + 0, 344, 345, 346, 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, - 0, 0, 0, 362, 363, 0, 1515, 366, 367, 0, + 0, 0, 0, 362, 363, 364, 0, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, - 0, 378, 379, 380, 381, 382, 1516, 384, 385, 386, + 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, - 396, 397, 398, 399, 400, 0, 401, 402, 1517, 404, - 405, 406, 1518, 408, 409, 410, 411, 412, 413, 414, - 415, 416, 417, 418, 419, 420, 0, 1519, 421, 422, - 423, 424, 425, 426, 1520, 428, 429, 0, 1521, 431, - 432, 1522, 434, 0, 435, 436, 437, 438, 439, 440, - 441, 442, 443, 444, 445, 446, 1523, 448, 0, 0, - 0, 450, 451, 0, 452, 1524, 454, 455, 456, 457, - 458, 0, 459, 1525, 1526, 0, 0, 462, 463, 0, - 465, 0, 0, 467, 468, 1527, 470, 471, 472, 473, - 474, 1528, 0, 475, 476, 477, 0, 478, 479, 480, - 481, 0, 482, 483, 484, 485, 486, 0, 1529, 0, - 489, 1530, 491, 492, 493, 494, 495, 496, 497, 0, + 396, 397, 398, 399, 400, 0, 401, 402, 0, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 0, 0, 431, + 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 530, 448, 449, 0, + 0, 450, 451, 1964, 452, 0, 454, 1965, 456, 1966, + 458, 0, 459, 460, 461, 0, 0, 462, 463, 464, + 465, 466, 0, 467, 468, 469, 470, 471, 472, 473, + 474, 0, 0, 475, 476, 1967, 0, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 487, 488, 0, + 489, 0, 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, - 1477, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 516, 517, 518, 519, 0, 0, 0, 0, 118, - 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, - 128, 0, 0, 0, 1478, 0, 0, 0, 0, 1479, - 130, 131, 0, 132, 133, 134, 1480, 136, 137, 138, - 0, 1481, 1482, 1483, 1484, 0, 144, 145, 146, 147, - 148, 149, 0, 0, 150, 151, 152, 153, 1485, 1486, - 156, 0, 157, 158, 159, 160, 0, 0, 1487, 0, - 1488, 164, 165, 166, 167, 168, 1489, 170, 171, 172, - 0, 173, 174, 175, 176, 177, 178, 0, 1490, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 1491, - 191, 192, 1492, 194, 0, 195, 0, 196, 197, 198, - 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, - 0, 206, 207, 1061, 209, 210, 0, 211, 212, 213, - 0, 1834, 215, 216, 0, 217, 218, 219, 220, 0, - 222, 223, 224, 225, 226, 227, 0, 0, 229, 0, - 230, 231, 1493, 233, 0, 234, 0, 235, 1494, 0, - 1495, 238, 239, 0, 1496, 242, 0, 243, 0, 0, - 0, 246, 247, 0, 248, 249, 250, 251, 252, 253, - 254, 1497, 256, 257, 258, 259, 0, 260, 261, 262, - 263, 264, 265, 266, 0, 267, 1498, 0, 270, 271, - 272, 273, 274, 1499, 1500, 0, 1501, 0, 278, 1502, - 1503, 281, 1504, 283, 284, 285, 286, 287, 288, 0, - 0, 289, 1505, 291, 1506, 0, 293, 294, 295, 296, - 297, 298, 299, 300, 1507, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 1508, 1509, 1510, 325, 326, - 327, 0, 0, 329, 330, 1511, 332, 0, 0, 334, - 1512, 336, 337, 338, 0, 339, 340, 0, 0, 341, - 342, 343, 0, 0, 344, 345, 0, 1513, 348, 1514, - 0, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, 361, 0, 0, 0, 0, 362, 363, 0, 1515, - 366, 367, 0, 369, 370, 371, 0, 372, 373, 374, - 375, 376, 377, 0, 378, 379, 380, 381, 382, 1516, - 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, - 402, 1517, 404, 405, 406, 1518, 408, 409, 410, 411, - 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, - 1519, 421, 422, 423, 424, 425, 426, 1520, 428, 429, - 0, 1521, 431, 432, 1522, 434, 0, 435, 436, 437, - 438, 439, 440, 441, 442, 443, 444, 445, 446, 1523, - 448, 0, 0, 0, 450, 451, 0, 452, 1524, 454, - 455, 456, 457, 458, 0, 459, 1525, 1526, 0, 0, - 462, 463, 0, 465, 0, 0, 467, 468, 1527, 470, - 471, 472, 473, 474, 1528, 0, 475, 476, 477, 0, - 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, - 0, 1529, 0, 489, 1530, 491, 492, 493, 494, 495, - 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, - 502, 503, 504, 3153, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 516, 517, 518, 519, 0, 0, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 527, 0, 553, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, + 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, + 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, + 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, + 151, 152, 153, 154, 155, 156, 0, 157, 158, 159, + 160, 161, 0, 0, 0, 163, 164, 165, 166, 167, + 168, 0, 170, 171, 172, 0, 173, 174, 175, 176, + 177, 178, 0, 0, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 0, + 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, + 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, + 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, + 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, + 234, 0, 235, 0, 0, 0, 238, 239, 528, 0, + 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, + 249, 250, 251, 252, 253, 254, 0, 256, 257, 258, + 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, + 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, + 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, + 285, 286, 287, 288, 0, 0, 289, 0, 291, 0, + 0, 293, 294, 295, 296, 297, 298, 299, 300, 529, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 0, 324, 325, 326, 327, 328, 0, 329, 330, + 0, 332, 0, 333, 334, 335, 336, 337, 338, 0, + 339, 340, 0, 0, 341, 342, 343, 0, 0, 344, + 345, 346, 0, 348, 0, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, + 0, 362, 363, 364, 0, 366, 367, 368, 369, 370, + 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, + 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, + 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, + 398, 399, 400, 0, 401, 402, 0, 404, 405, 406, + 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, + 425, 426, 427, 428, 429, 0, 0, 431, 432, 433, + 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, + 443, 444, 445, 446, 530, 448, 449, 0, 0, 450, + 451, 0, 452, 0, 454, 455, 456, 457, 458, 0, + 459, 460, 461, 0, 0, 462, 463, 464, 465, 466, + 0, 467, 468, 469, 470, 471, 472, 473, 474, 0, + 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, + 482, 483, 484, 485, 486, 487, 488, 0, 489, 0, + 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, + 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, + 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, + 517, 518, 519, 527, 0, 819, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, - 0, 126, 127, 128, 0, 0, 0, 2905, 0, 0, - 0, 0, 2906, 130, 131, 0, 132, 133, 134, 2907, - 136, 137, 138, 0, 1481, 2908, 1483, 1484, 0, 144, + 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, + 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, - 153, 1485, 1486, 156, 0, 157, 158, 159, 160, 0, - 0, 2909, 0, 2910, 164, 165, 166, 167, 168, 2911, + 153, 154, 155, 156, 0, 157, 158, 159, 160, 161, + 0, 0, 0, 163, 164, 165, 166, 167, 168, 0, 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, - 0, 2912, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 1491, 191, 192, 1492, 194, 0, 195, 0, + 0, 0, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, - 204, 205, 0, 0, 206, 207, 1061, 209, 210, 0, + 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, - 219, 220, 0, 222, 223, 224, 225, 226, 227, 0, - 0, 229, 0, 230, 231, 1493, 233, 0, 234, 0, - 235, 2913, 0, 2914, 238, 239, 2915, 2916, 242, 0, - 243, 0, 0, 0, 246, 247, 0, 248, 249, 250, - 251, 252, 253, 254, 2917, 256, 257, 258, 259, 0, - 260, 261, 262, 263, 264, 265, 266, 0, 267, 2918, - 0, 270, 271, 272, 273, 274, 1499, 1500, 0, 1501, - 0, 278, 2919, 2920, 281, 2921, 283, 284, 285, 286, - 287, 288, 0, 0, 289, 2922, 291, 2923, 0, 293, - 294, 295, 296, 297, 298, 299, 300, 3154, 302, 303, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, + 235, 0, 0, 0, 238, 239, 528, 0, 242, 0, + 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, + 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, + 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, + 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, + 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, + 287, 288, 0, 0, 289, 0, 291, 0, 0, 293, + 294, 295, 296, 297, 298, 299, 300, 529, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 321, 1508, 2925, - 1510, 325, 326, 327, 0, 0, 329, 330, 2927, 332, - 0, 0, 334, 1512, 336, 337, 338, 0, 339, 340, - 0, 0, 341, 342, 343, 0, 0, 344, 345, 0, - 2929, 348, 2930, 0, 351, 352, 353, 354, 355, 356, + 314, 315, 316, 317, 318, 319, 320, 321, 322, 0, + 324, 325, 326, 327, 328, 0, 329, 330, 0, 332, + 0, 333, 334, 335, 336, 337, 338, 0, 339, 340, + 0, 0, 341, 342, 343, 0, 0, 344, 345, 346, + 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, - 363, 0, 2931, 366, 367, 0, 369, 370, 371, 0, + 363, 364, 0, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, - 381, 382, 1516, 384, 385, 386, 387, 0, 388, 389, + 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, - 400, 0, 401, 402, 2932, 404, 405, 406, 0, 408, + 400, 0, 401, 402, 0, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, - 419, 420, 0, 2933, 421, 422, 423, 424, 425, 426, - 0, 428, 429, 0, 2935, 431, 432, 1522, 434, 0, + 419, 420, 0, 0, 421, 422, 423, 424, 425, 426, + 427, 428, 429, 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, - 445, 446, 3155, 448, 0, 0, 0, 450, 451, 0, - 452, 2937, 454, 455, 456, 457, 458, 0, 459, 1525, - 1526, 0, 0, 462, 463, 0, 465, 0, 0, 467, - 468, 2938, 470, 471, 472, 473, 474, 0, 0, 475, + 445, 446, 530, 448, 449, 0, 0, 450, 451, 0, + 452, 0, 454, 455, 456, 457, 458, 0, 459, 460, + 461, 0, 0, 462, 463, 464, 465, 466, 0, 467, + 468, 469, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, - 484, 485, 486, 0, 1529, 0, 489, 2940, 491, 492, + 484, 485, 486, 487, 488, 0, 489, 0, 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, - 499, 500, 501, 502, 503, 504, 527, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 516, 517, 518, - 519, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, - 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, - 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, - 150, 151, 152, 153, 154, 155, 156, 0, 157, 158, - 159, 160, 161, 0, 0, 0, 163, 164, 165, 166, - 167, 168, 0, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 0, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, - 0, 234, 0, 235, 0, 0, 0, 238, 239, 528, - 0, 242, 0, 243, 0, 244, 245, 0, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 0, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, - 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 0, 291, - 0, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 529, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 0, 324, 325, 326, 327, 328, 0, 329, - 330, 0, 332, 0, 333, 334, 335, 336, 337, 338, - 0, 339, 340, 0, 0, 341, 342, 343, 0, 0, - 344, 345, 346, 0, 348, 0, 350, 351, 352, 353, - 354, 355, 356, 0, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 364, 0, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 0, 382, 383, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 0, 404, 405, - 406, 407, 0, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 0, 431, 432, - 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 530, 448, 449, 0, 0, - 450, 451, 0, 452, 0, 454, 455, 456, 457, 458, - 0, 459, 460, 461, 0, 0, 462, 463, 464, 465, - 466, 0, 467, 468, 469, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 488, 0, 489, - 0, 491, 492, 493, 494, 495, 496, 497, 0, 0, - 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 1771, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, - 125, 0, 126, 127, 128, 0, 0, 0, 1478, 0, - 0, 0, 0, 1479, 130, 131, 0, 132, 133, 134, - 1480, 136, 137, 138, 0, 1481, 1482, 1483, 1484, 0, - 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, - 152, 153, 1485, 1486, 156, 0, 157, 158, 159, 160, - 0, 0, 1487, 0, 1488, 164, 165, 166, 167, 168, - 1489, 170, 171, 172, 0, 173, 174, 175, 176, 177, - 178, 0, 1490, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 1491, 191, 192, 1492, 194, 0, 195, - 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, - 203, 204, 205, 0, 0, 206, 207, 1061, 209, 210, - 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, - 218, 219, 220, 0, 222, 223, 224, 225, 226, 227, - 0, 0, 229, 0, 230, 231, 1493, 233, 0, 234, - 0, 235, 1494, 0, 1495, 238, 239, 0, 1496, 242, - 0, 243, 0, 0, 0, 246, 247, 0, 248, 249, - 250, 251, 252, 253, 254, 1497, 256, 257, 258, 259, - 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, - 1498, 0, 270, 271, 272, 273, 274, 1499, 1500, 0, - 1501, 0, 278, 1502, 1503, 281, 1504, 283, 284, 285, - 286, 287, 288, 0, 0, 289, 1505, 291, 1506, 0, - 293, 294, 295, 296, 297, 298, 299, 300, 0, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 1508, - 1509, 1510, 325, 326, 327, 0, 0, 329, 330, 1511, - 332, 0, 0, 334, 1512, 336, 337, 338, 0, 339, - 340, 0, 0, 341, 342, 343, 0, 0, 344, 345, - 0, 1513, 348, 1514, 0, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, - 362, 363, 0, 1515, 366, 367, 0, 369, 370, 371, - 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, - 380, 381, 382, 1516, 384, 385, 386, 387, 0, 388, - 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, - 399, 400, 0, 401, 402, 1517, 404, 405, 406, 0, - 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 0, 1519, 421, 422, 423, 424, 425, - 426, 0, 428, 429, 0, 1521, 431, 432, 1522, 434, - 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, - 444, 445, 446, 0, 448, 0, 0, 0, 450, 451, - 0, 452, 1524, 454, 455, 456, 457, 458, 0, 459, - 1525, 1526, 0, 0, 462, 463, 0, 465, 0, 0, - 467, 468, 1527, 470, 471, 472, 473, 474, 0, 0, - 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, - 483, 484, 485, 486, 0, 1529, 0, 489, 1530, 491, - 492, 493, 494, 495, 496, 497, 0, 1, 498, 0, - 0, 499, 500, 501, 502, 503, 504, 2, 0, 3, - 4, 0, 0, 0, 0, 1, 0, 0, 516, 517, - 518, 519, 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, 750, 0, 0, 0, 10, - 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, - 0, 11, 0, 750, 0, 0, 0, 0, 0, 0, - 0, 14, 15, 0, 13, 0, 0, 0, 0, 0, - 0, 0, 751, 0, 0, 0, 0, 0, 18, 14, - 15, 0, 0, 0, 0, 0, 19, 0, 0, 0, - 751, 0, 0, 0, 0, 0, 18, 0, 0, 0, - 0, 0, 0, 22, 19, 0, 0, 23, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 22, 0, 0, 0, 23, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, -1424, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, -1424, 0, 0, - 0, 0, 0, 0, 0, 25, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 25, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 26, 27, 28, 0, 0, 0, 0, 0, 29, 0, - 0, 30, 0, 0, 0, 0, 0, 0, 26, 27, - 28, 0, 0, 0, 0, 0, 29, 0, 0, 30, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 31, 0, 0, 0, 0, 0, 0, 0, - 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, - 31, 0, 0, 0, 0, 0, 0, 33, 0, 32, - 0, 0, 0, 0, 34, 0, 0, 0, 35, 0, - 0, 0, 0, 0, 0, 33, 0, 0, 36, 0, - 0, 0, 34, 0, 0, 0, 35, 0, 0, 0, - 37, 0, 0, 0, 38, 0, 36, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 37, 0, - 0, 0, 38, 0, 39, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 40, 0, 0, - 0, 0, 39, 42, 0, 0, 0, 0, 43, 0, - 0, 0, 752, 0, 0, 40, 0, 0, 0, 0, - 0, 42, 0, 0, 44, 0, 43, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 44, 0, 0, 0, 0, 0, 45, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 753, 0, 0, 0, 45, 0, 0, 0, + 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, + 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, + 519, 527, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 46 -}; - -static const yytype_int16 yycheck[] = -{ - 7, 899, 0, 46, 0, 0, 0, 520, 0, 16, - 0, 0, 89, 90, 0, 0, 23, 16, 0, 0, - 87, 838, 20, 38, 20, 23, 0, 887, 7, 813, - 7, 1240, 861, 745, 1227, 20, 908, 1698, 753, 37, - 1424, 993, 924, 1159, 23, 1034, 23, 976, 46, 929, - 1214, 37, 1201, 91, 1226, 1081, 20, 91, 23, 984, - 959, 1575, 1656, 1549, 984, 1280, 984, 2180, 984, 1165, - 1203, 2166, 1802, 17, 1206, 1470, 963, 2235, 1609, 1610, - 0, 1302, 89, 90, 0, 2345, 0, 0, 976, 2657, - 23, 89, 90, 91, 1989, 0, 111, 45, 1231, 0, - 2231, 1327, 0, 1126, 2111, 103, 0, 0, 1131, 34, - 89, 90, 89, 90, 2165, 753, 2659, 103, 2621, 2680, - 0, 2621, 0, 0, 89, 90, 0, 0, 0, 2145, - 1002, 2147, 2673, 0, 0, 0, 0, 1089, 809, 0, - 2493, 0, 746, 814, 752, 2302, 0, 1990, 2283, 2284, - 2285, 2577, 0, 982, 9, 2581, 89, 90, 5, 5, - 0, 1718, 1826, 5, 1820, 1823, 13, 14, 1716, 1965, - 2313, 899, 1035, 901, 63, 903, 5, 0, 1055, 1056, - 1660, 80, 1978, 771, 5, 55, 5, 5, 63, 2320, - 5, 9, 5, 2314, 2309, 1072, 9, 5, 13, 14, - 5, 985, 5, 1932, 5, 5, 5, 5, 1137, 2992, - 13, 14, 13, 14, 13, 14, 5, 45, 11, 107, - 2978, 13, 14, 16, 5, 5, 5, 5, 5, 74, - 82, 45, 119, 172, 191, 26, 882, 2995, 13, 14, - 124, 93, 2373, 2374, 4, 2376, 82, 139, 30, 9, - 11, 104, 2444, 63, 5, 16, 38, 93, 1247, 1088, - 100, 976, 173, 3, 4, 5, 4, 1256, 30, 9, - 1142, 9, 122, 30, 1137, 9, 38, 100, 122, 90, - 3158, 38, 856, 882, 147, 46, 1215, 1169, 2833, 1218, - 1219, 291, 2444, 806, 2951, 288, 122, 126, 127, 2879, - 3, 11, 172, 172, 276, 15, 16, 290, 296, 11, - 245, 313, 107, 15, 16, 986, 3288, 107, 129, 80, - 2814, 37, 2816, 1439, 169, 193, 1059, 998, 181, 313, - 382, 34, 35, 245, 119, 2537, 46, 2539, 132, 40, - 853, 40, 1075, 172, 46, 203, 137, 3321, 11, 296, - 184, 1214, 15, 16, 1470, 218, 1520, 106, 132, 181, - 193, 3353, 41, 213, 117, 368, 1195, 369, 391, 977, - 80, 3486, 53, 2591, 1191, 1192, 120, 117, 80, 3, - 409, 5, 108, 457, 1035, 30, 117, 213, 279, 148, - 166, 3397, 1613, 359, 457, 479, 30, 433, 418, 164, - 1553, 122, 108, 2538, 2134, 120, 3346, 3347, 33, 1562, - 3382, 2427, 3527, 3385, 515, 481, 137, 1902, 519, 503, - 273, 2989, 164, 389, 172, 11, 1286, 3185, 1310, 15, - 16, 2934, 2590, 296, 59, 64, 456, 503, 373, 1302, - 85, 200, 471, 517, 2987, 74, 482, 126, 1933, 94, - 290, 195, 2565, 3445, 517, 2998, 2587, 173, 2589, 3399, - 191, 373, 1342, 1958, 1959, 1960, 192, 290, 171, 521, - 173, 360, 3446, 118, 2692, 176, 3482, 176, 2485, 219, - 195, 275, 454, 273, 329, 360, 315, 316, 317, 231, - 358, 285, 431, 209, 517, 280, 177, 308, 132, 3156, - 1526, 241, 251, 294, 3287, 396, 340, 272, 3480, 225, - 512, 285, 261, 194, 517, 373, 451, 517, 199, 235, - 245, 361, 355, 2725, 517, 3019, 384, 280, 512, 280, - 1751, 419, 4, 521, 517, 369, 3116, 9, 361, 451, - 538, 63, 3420, 2686, 275, 13, 191, 1193, 324, 2741, - 360, 19, 538, 382, 2669, 3135, 237, 3102, 290, 204, - 517, 419, 30, 1214, 393, 1153, 357, 506, 359, 2690, - 149, 2702, 459, 457, 521, 428, 44, 45, 373, 431, - 519, 1094, 517, 475, 447, 592, 415, 1982, 416, 2741, - 419, 1806, 1166, 592, 1193, 431, 1745, 2111, 389, 468, - 3383, 1430, 416, 448, 454, 517, 517, 328, 1485, 1486, - 454, 469, 241, 424, 1326, 25, 515, 399, 2149, 1331, - 519, 2516, 201, 452, 466, 1337, 3384, 1444, 454, 1344, - 2187, 3172, 521, 1510, 463, 457, 1862, 399, 2186, 479, - 75, 109, 399, 1460, 2440, 1838, 521, 517, 364, 245, - 479, 1302, 13, 14, 2383, 3158, 479, 1520, 3158, 2315, - 481, 516, 481, 517, 2322, 2179, 520, 383, 1877, 1658, - 517, 517, 520, 1894, 503, 517, 523, 523, 518, 2343, - 520, 3107, 503, 431, 503, 1906, 3112, 518, 517, 2169, - 521, 30, 2850, 1570, 1571, 518, 517, 520, 517, 517, - 2857, 3088, 517, 3090, 517, 115, 1344, 515, 3061, 517, - 753, 519, 517, 394, 517, 1936, 517, 517, 517, 517, - 513, 2981, 1943, 1552, 1553, 517, 451, 804, 517, 1333, - 1602, 1603, 1604, 1562, 3295, 1343, 517, 517, 517, 517, - 517, 479, 517, 3286, 259, 260, 753, 1576, 508, 509, - 1613, 273, 513, 3294, 752, 753, 752, 11, 1979, 1492, - 405, 804, 1983, 408, 467, 503, 1437, 752, 508, 509, - 508, 509, 1987, 266, 508, 509, 1605, 373, 59, 1512, - 2831, 162, 406, 407, 1012, 82, 793, 227, 108, 753, - 1018, 2012, 517, 132, 250, 793, 93, 804, 508, 509, - 510, 511, 512, 513, 345, 423, 804, 425, 510, 511, - 512, 513, 3380, 851, 793, 1548, 793, 851, 173, 275, - 887, 2716, 13, 14, 3211, 804, 80, 804, 321, 1945, - 2837, 838, 839, 273, 2884, 2970, 13, 14, 360, 804, - 506, 856, 2892, 384, 74, 2976, 1775, 510, 511, 512, - 513, 517, 3395, 851, 861, 451, 1785, 238, 1847, 1788, - 793, 876, 518, 378, 379, 521, 1982, 389, 419, 1520, - 3438, 804, 1770, 871, 178, 871, 871, 871, 419, 871, - 506, 871, 871, 162, 11, 871, 871, 117, 1751, 871, - 871, 172, 515, 519, 517, 859, 519, 871, 2793, 906, - 907, 341, 517, 910, 911, 1418, 2636, 2750, 2638, 2135, - 2753, 0, 2755, 1625, 862, 840, 841, 3420, 843, 46, - 3420, 517, 508, 509, 510, 511, 512, 513, 469, 245, - 1953, 82, 1009, 2428, 2429, 2430, 2431, 241, 3198, 1016, - 520, 5, 93, 1803, 1804, 1805, 2062, 40, 1828, 1878, - 467, 871, 392, 80, 309, 871, 963, 871, 871, 238, - 3118, 1860, 1613, 3506, 214, 1864, 871, 60, 1867, 976, - 871, 2485, 2503, 871, 981, 982, 167, 871, 871, 977, - 987, 977, 1869, 990, 991, 929, 993, 994, 995, 996, - 1878, 871, 977, 871, 871, 227, 119, 871, 871, 871, - 13, 14, 1009, 3098, 871, 871, 871, 871, 287, 1016, - 871, 1009, 871, 106, 454, 1743, 1885, 4, 1016, 162, - 1889, 2405, 9, 1892, 167, 521, 1033, 1034, 1035, 245, - 1009, 1894, 1009, 117, 315, 316, 317, 1016, 275, 1016, - 395, 273, 1770, 1906, 1009, 275, 1089, 1054, 5, 275, - 280, 1016, 1050, 172, 280, 2151, 37, 373, 2154, 2545, - 518, 132, 1790, 521, 1062, 2258, 1073, 1795, 132, 1781, - 3247, 2286, 3249, 1936, 1786, 2805, 1009, 1084, 1085, 1086, - 1943, 1088, 1089, 1016, 207, 4, 1093, 555, 172, 160, - 9, 1089, 481, 2209, 1093, 238, 160, 516, 174, 329, - 1751, 382, 517, 2324, 3262, 4, 174, 2621, 527, 202, - 9, 516, 1941, 339, 503, 1122, 1979, 347, 3013, 423, - 1983, 425, 527, 481, 245, 515, 1989, 515, 517, 519, - 517, 519, 1139, 1140, 2267, 451, 1174, 1175, 419, 1177, - 1174, 1175, 108, 1177, 287, 503, 512, 451, 3325, 2012, - 273, 1166, 275, 519, 423, 512, 425, 373, 251, 517, - 392, 26, 519, 1878, 826, 827, 828, 32, 261, 1176, - 246, 452, 1007, 1180, 1181, 355, 1174, 1175, 246, 1177, - 273, 380, 463, 1190, 1191, 1192, 380, 1017, 1195, 2141, - 1025, 1021, 173, 203, 1029, 2024, 315, 316, 317, 2331, - 518, 517, 132, 521, 275, 2337, 515, 1214, 517, 280, - 518, 275, 305, 521, 285, 1230, 280, 423, 448, 425, - 304, 285, 454, 1429, 252, 1431, 1432, 457, 209, 345, - 160, 315, 316, 317, 8, 451, 517, 11, 2459, 436, - 1247, 15, 16, 1894, 225, 19, 20, 21, 419, 1256, - 840, 841, 373, 843, 235, 1906, 518, 518, 26, 521, - 521, 469, 36, 382, 32, 479, 359, 481, 384, 345, - 2099, 377, 137, 1280, 55, 518, 8, 345, 521, 747, - 2241, 380, 2243, 15, 16, 1936, 2146, 19, 20, 21, - 518, 384, 1943, 521, 518, 1302, 518, 521, 382, 521, - 419, 517, 2587, 419, 2589, 517, 1301, 1301, 384, 1301, - 403, 1318, 1301, 167, 518, 518, 384, 521, 521, 1318, - 1327, 102, 518, 2837, 2719, 521, 2442, 517, 1979, 2445, - 451, 162, 1983, 452, 517, 419, 167, 1344, 1989, 2238, - 3498, 2240, 123, 419, 463, 1343, 518, 1343, 517, 521, - 280, 419, 517, 469, 1361, 285, 71, 72, 1343, 1366, - 141, 2012, 1361, 518, 145, 517, 521, 438, 452, 137, - 3483, 517, 3485, 1450, 438, 172, 1453, 787, 449, 463, - 1344, 1458, 517, 364, 1461, 449, 517, 168, 518, 1466, - 171, 521, 517, 469, 862, 479, 517, 2214, 517, 517, - 2621, 469, 383, 423, 517, 425, 187, 238, 818, 1416, - 1417, 2604, 879, 3526, 881, 1422, 510, 1424, 518, 503, - 503, 521, 1429, 1430, 1431, 1432, 2635, 178, 500, 294, - 2312, 2603, 842, 517, 3450, 13, 14, 1444, 1445, 2588, - 224, 518, 290, 1450, 521, 1424, 1453, 1424, 222, 3465, - 519, 1458, 1450, 1460, 1461, 1453, 287, 13, 14, 1466, - 1458, 2324, 500, 1461, 2490, 2491, 518, 877, 1466, 521, - 2602, 1450, 2604, 1450, 1453, 178, 1453, 13, 14, 1458, - 2652, 1458, 1461, 518, 1461, 1450, 521, 1466, 1453, 1466, - 241, 1424, 357, 1458, 518, 40, 1461, 521, 519, 280, - 203, 1466, 518, 518, 3520, 521, 521, 288, 438, 3525, - 3240, 518, 3242, 1520, 521, 60, 171, 1450, 292, 449, - 1453, 13, 14, 521, 389, 1458, 294, 517, 1461, 310, - 2359, 172, 518, 1466, 518, 521, 518, 521, 241, 521, - 518, 2493, 2467, 2468, 2469, 1552, 1553, 2467, 2468, 2467, - 2466, 1549, 295, 1549, 1561, 1562, 13, 14, 339, 1549, - 292, 106, 1569, 1549, 1549, 518, 976, 1549, 1549, 1576, - 518, 13, 14, 521, 984, 1549, 518, 518, 518, 521, - 8, 521, 59, 11, 147, 353, 517, 15, 16, 357, - 518, 420, 295, 521, 1601, 460, 2459, 518, 1605, 162, - 521, 1608, 518, 500, 167, 521, 1613, 1614, 1615, 1616, - 1617, 1618, 1619, 1620, 1621, 1622, 13, 14, 46, 1626, - 1627, 389, 373, 1622, 1631, 53, 518, 224, 1635, 521, - 1628, 1638, 1639, 1640, 1641, 1642, 1643, 1644, 1645, 1646, - 518, 2353, 1649, 521, 3158, 2360, 13, 14, 152, 1656, - 6, 1658, 80, 2516, 10, 218, 3250, 202, 13, 14, - 13, 14, 18, 1701, 13, 14, 353, 1701, 13, 14, - 1677, 152, 423, 2324, 425, 238, 32, 13, 14, 2900, - 36, 152, 2554, 13, 14, 13, 14, 152, 1098, 152, - 1158, 419, 460, 13, 14, 26, 40, 1704, 1108, 518, - 451, 32, 2851, 1701, 517, 2898, 251, 275, 1715, 1716, - 469, 1675, 13, 14, 13, 14, 261, 145, 1128, 40, - 423, 89, 425, 26, 287, 13, 14, 1137, 273, 32, - 504, 505, 506, 296, 508, 509, 510, 511, 512, 513, - 152, 26, 13, 14, 1751, 448, 152, 32, 451, 177, - 189, 190, 483, 1760, 519, 1762, 13, 14, 2621, 152, - 305, 1760, 2579, 1762, 152, 2974, 194, 13, 14, 290, - 2934, 199, 504, 505, 506, 431, 508, 509, 510, 511, - 512, 513, 2642, 2663, 368, 369, 355, 3448, 368, 369, - 517, 3452, 368, 369, 517, 1802, 2695, 178, 517, 1806, - 1035, 2683, 1809, 1810, 368, 369, 137, 518, 2459, 237, - 263, 264, 378, 379, 359, 462, 463, 2806, 3202, 517, - 259, 260, 2171, 2172, 3460, 3461, 3492, 3493, 1139, 1140, - 421, 220, 300, 225, 137, 3056, 1834, 517, 225, 384, - 1847, 225, 517, 297, 40, 1843, 3507, 517, 5, 517, - 236, 325, 137, 2716, 5, 1862, 517, 1843, 403, 517, - 241, 5, 1869, 1870, 292, 2516, 1334, 517, 1336, 5, - 26, 1878, 517, 5, 517, 5, 32, 26, 148, 517, - 9, 517, 480, 32, 447, 302, 521, 1894, 104, 1966, - 521, 1898, 1899, 518, 1901, 1972, 220, 40, 389, 1906, - 1907, 1908, 1909, 1910, 1911, 1912, 3420, 167, 1915, 1916, - 1917, 1918, 1919, 1920, 1921, 1922, 1923, 1924, 287, 167, - 285, 59, 236, 1930, 1931, 517, 431, 1934, 517, 1936, - 2793, 126, 127, 314, 1941, 93, 1943, 3158, 521, 378, - 379, 431, 59, 59, 431, 431, 108, 266, 527, 222, - 1360, 431, 431, 479, 380, 152, 1963, 275, 100, 1966, - 2889, 1968, 275, 294, 517, 1972, 394, 40, 1966, 3353, - 2621, 275, 1979, 518, 1972, 275, 1983, 172, 1985, 1214, - 1987, 137, 1989, 517, 275, 199, 152, 1966, 137, 1966, - 172, 294, 373, 1972, 519, 1972, 13, 3169, 518, 380, - 518, 1966, 2901, 2902, 1035, 2012, 518, 1972, 172, 294, - 518, 518, 3396, 225, 517, 521, 518, 2024, 2025, 518, - 476, 225, 353, 282, 282, 521, 357, 39, 517, 517, - 466, 475, 517, 1966, 2746, 519, 519, 2900, 9, 1972, - 355, 517, 423, 11, 425, 517, 429, 517, 517, 429, - 353, 517, 516, 429, 357, 280, 2099, 2064, 389, 521, - 527, 3445, 2069, 2070, 524, 2716, 521, 1302, 353, 517, - 451, 2934, 357, 501, 82, 3284, 3028, 517, 181, 431, - 508, 509, 510, 511, 512, 513, 389, 2094, 2095, 37, - 172, 163, 2099, 457, 42, 518, 521, 218, 266, 521, - 108, 2099, 392, 227, 389, 8, 2113, 291, 11, 2116, - 3226, 2118, 15, 16, 313, 313, 19, 20, 21, 2117, - 315, 316, 317, 521, 181, 521, 220, 2134, 2135, 460, - 227, 227, 334, 518, 2141, 2133, 8, 2144, 294, 11, - 517, 275, 2793, 15, 16, 294, 2144, 19, 20, 21, - 3013, 296, 469, 101, 2161, 288, 517, 460, 2870, 517, - 152, 152, 152, 2161, 152, 2144, 174, 2144, 479, 40, - 152, 2178, 3, 275, 517, 460, 290, 3, 290, 2144, - 40, 59, 2161, 1214, 2161, 172, 11, 382, 2195, 2196, - 40, 167, 518, 3056, 517, 203, 2161, 353, 393, 3420, - 181, 357, 518, 167, 353, 2212, 518, 2214, 357, 518, - 517, 2144, 517, 3, 3, 39, 2223, 515, 515, 521, - 415, 431, 431, 431, 419, 173, 431, 519, 2161, 518, - 3423, 518, 516, 389, 2241, 2242, 2243, 518, 246, 976, - 389, 524, 2241, 2242, 2243, 500, 518, 178, 500, 2900, - 518, 518, 518, 518, 3136, 518, 1666, 452, 500, 172, - 431, 209, 8, 517, 517, 11, 517, 517, 463, 15, - 16, 1302, 203, 2280, 155, 2318, 250, 225, 1746, 2286, - 1690, 1691, 517, 2934, 479, 1520, 476, 235, 1756, 40, - 1758, 59, 521, 1761, 3009, 3158, 468, 291, 291, 1767, - 46, 1769, 502, 506, 460, 244, 454, 53, 503, 59, - 241, 460, 2307, 2307, 1782, 2307, 59, 2324, 2307, 1787, - 2318, 269, 517, 1791, 1792, 1793, 1794, 199, 1796, 1797, - 521, 266, 431, 275, 80, 2342, 517, 152, 2345, 203, - 152, 152, 290, 431, 431, 431, 2345, 431, 282, 282, - 222, 518, 2359, 2360, 517, 40, 517, 355, 518, 288, - 2367, 479, 3013, 40, 295, 373, 521, 315, 2367, 290, - 152, 1108, 280, 172, 322, 59, 384, 518, 1613, 518, - 3252, 518, 517, 3212, 186, 3214, 517, 167, 1798, 292, - 518, 80, 515, 518, 143, 199, 518, 172, 2405, 145, - 1137, 1811, 1812, 518, 517, 3056, 517, 3224, 518, 518, - 301, 419, 518, 517, 521, 361, 364, 291, 518, 527, - 292, 181, 152, 521, 176, 518, 2405, 517, 2405, 442, - 519, 177, 40, 518, 442, 383, 517, 2444, 518, 518, - 517, 517, 373, 3227, 518, 3229, 521, 40, 194, 86, - 2493, 457, 2459, 199, 521, 172, 2471, 517, 478, 3411, - 518, 469, 518, 199, 2531, 518, 3364, 516, 1878, 2476, - 516, 521, 2405, 3355, 1884, 2482, 2483, 518, 1215, 518, - 518, 1218, 1219, 2526, 518, 3345, 2493, 290, 463, 1520, - 506, 237, 423, 59, 425, 2493, 518, 2504, 205, 518, - 2507, 479, 2509, 518, 452, 117, 40, 3158, 518, 2516, - 2517, 442, 517, 2520, 2521, 227, 1751, 448, 2525, 2526, - 451, 88, 3339, 192, 280, 2532, 280, 506, 2526, 431, - 519, 431, 40, 519, 519, 519, 2579, 275, 107, 519, - 2547, 40, 519, 516, 516, 290, 292, 2545, 518, 2545, - 2557, 517, 519, 2551, 519, 2545, 519, 3420, 519, 2545, - 2545, 7, 8, 2545, 2545, 2551, 519, 13, 479, 519, - 519, 2545, 2579, 19, 519, 519, 519, 23, 519, 25, - 518, 2579, 1613, 29, 30, 31, 9, 519, 34, 519, - 518, 37, 38, 519, 519, 41, 519, 519, 44, 45, - 519, 504, 505, 506, 519, 508, 509, 510, 511, 512, - 513, 2618, 1349, 1350, 2621, 2622, 521, 2624, 519, 2618, - 519, 519, 519, 2622, 519, 2624, 519, 517, 517, 2636, - 354, 2638, 504, 505, 506, 517, 508, 509, 510, 511, - 512, 513, 517, 89, 90, 336, 59, 199, 394, 518, - 518, 521, 192, 37, 516, 521, 462, 103, 42, 1894, - 2658, 91, 108, 109, 110, 111, 112, 2662, 2662, 98, - 2662, 1906, 2658, 2662, 518, 347, 517, 40, 152, 519, - 518, 3393, 124, 152, 40, 518, 369, 2685, 2156, 369, - 2688, 40, 40, 521, 517, 2738, 518, 126, 127, 2685, - 517, 1936, 2688, 517, 457, 310, 2713, 517, 1943, 2716, - 280, 249, 191, 457, 442, 74, 517, 101, 293, 74, - 1751, 9, 80, 518, 518, 517, 2733, 2734, 371, 516, - 518, 2738, 516, 59, 2741, 133, 2813, 506, 273, 93, - 2738, 290, 442, 172, 1979, 40, 517, 293, 1983, 293, - 517, 462, 518, 518, 1989, 501, 518, 205, 290, 290, - 518, 2768, 508, 509, 510, 511, 512, 513, 389, 3420, - 122, 368, 454, 148, 25, 2782, 36, 2012, 368, 298, - 2787, 2788, 2894, 1768, 2827, 2792, 2793, 2236, 871, 173, - 2797, 2618, 1676, 2800, 2801, 1238, 2605, 181, 2805, 2806, - 2279, 1812, 2809, 2306, 2367, 3318, 2813, 147, 3009, 3370, - 3475, 2654, 3129, 2820, 3424, 2813, 3433, 3187, 3468, 788, - 2229, 2242, 162, 1201, 3422, 209, 2597, 167, 3431, 2827, - 1567, 2226, 3419, 2674, 2813, 2348, 2813, 2624, 2248, 1298, - 1869, 225, 1579, 2556, 1581, 3316, 1344, 3254, 2813, 3396, - 2555, 235, 3349, 1326, 147, 3497, 877, 2864, 74, 2545, - 2212, 1008, 1158, 1894, 80, 2872, 2334, 1740, 1008, 162, - 1607, 2178, 2426, 1183, 167, 1906, 1184, 93, 218, 3405, - 2813, 1035, 2195, 1704, 2891, 269, 315, 316, 317, 3327, - 2300, 3216, 1739, 2900, 23, 2161, 1977, 3051, 238, 2405, - 1186, 117, 2741, 119, 2404, 1936, 290, 793, 2318, 2451, - 804, 3150, 1943, 1992, 0, 986, 984, 1878, 984, 984, - 984, 984, 984, 984, 1878, 218, 3331, 2934, 3330, 984, - 984, 315, 2071, 2483, 2179, 2117, 2026, 2820, 322, 2114, - 2073, 2500, 1675, 1985, 1445, 238, 103, 287, 1979, -1, - 2360, -1, 1983, 382, -1, -1, 296, -1, 1989, 2369, - -1, 2371, -1, -1, 393, 2375, -1, 2377, -1, -1, - -1, -1, -1, 2980, 2981, -1, -1, -1, 1715, 1716, - 364, 2012, 2981, -1, -1, 3028, 415, -1, -1, -1, - 419, 207, 2990, -1, 287, -1, -1, -1, -1, 383, - -1, -1, 3009, 296, 2990, 3012, 3013, -1, -1, -1, - 439, -1, -1, -1, 100, -1, -1, -1, -1, -1, - -1, 3028, -1, 452, -1, -1, -1, -1, 8, -1, - 3028, 11, -1, -1, 463, 15, 16, -1, 1775, 19, - 20, 21, -1, -1, -1, -1, -1, -1, 1785, 3056, - 479, 1788, -1, -1, 3061, -1, -1, -1, -1, 275, - 1214, 147, -1, -1, 280, 3072, 3073, -1, 452, 3076, - -1, 3078, -1, 457, 503, -1, 162, -1, -1, -1, - -1, 167, -1, -1, 1035, -1, 172, -1, 517, 2324, - -1, -1, -1, 539, -1, 181, 3103, -1, 544, -1, - 186, 547, -1, -1, -1, -1, -1, 447, 1035, 555, - -1, -1, -1, 329, 2582, 2583, 8, -1, -1, 11, - 3127, -1, -1, 15, 16, -1, -1, 19, 20, 21, - -1, 347, 218, -1, -1, -1, -1, -1, -1, -1, - -1, 1878, 2610, -1, 36, -1, -1, -1, 1302, -1, - -1, 3158, 238, -1, 447, -1, -1, 2625, 2626, 2627, - 2628, 2629, 2630, 2631, 2632, 2633, 2634, -1, -1, -1, - -1, -1, -1, -1, -1, 515, 3174, 3175, 518, 519, - -1, -1, -1, -1, 991, -1, -1, -1, 3174, 3175, - 3197, 3198, -1, -1, -1, 3202, -1, -1, -1, 3198, - -1, 287, -1, -1, 290, 3212, -1, 3214, -1, 3216, - 296, 2621, -1, 3220, -1, 3222, -1, 3224, -1, 199, - -1, -1, 515, 3202, 2459, 3202, 519, -1, 3235, -1, - -1, -1, 448, 3240, -1, 3242, -1, -1, -1, -1, - -1, 457, 222, 3250, 2654, -1, -1, -1, -1, -1, - 336, -1, -1, 3251, -1, 3253, 3263, -1, -1, 1996, - -1, 3268, -1, 1214, 3263, 3251, -1, 3253, -1, 3202, - -1, 8, -1, -1, 11, 361, -1, -1, 15, 16, - -1, 2516, -1, -1, -1, -1, -1, 1214, 40, -1, - -1, -1, -1, 2324, -1, 3293, -1, -1, -1, 745, - 746, 747, -1, -1, -1, -1, -1, 3293, 60, 46, - 3317, 3309, 292, -1, -1, 3313, 53, -1, -1, -1, - 3327, -1, -1, 3309, -1, -1, -1, 3313, -1, -1, - 222, -1, 3339, 419, -1, 991, -1, -1, -1, -1, - -1, 787, 788, 80, -1, -1, 3353, 793, -1, 795, - 37, 1302, -1, -1, 106, 42, -1, -1, 804, -1, - -1, 447, 808, 809, 3371, -1, 1520, 813, 814, -1, - -1, 457, -1, -1, 3353, 1302, 3353, -1, -1, -1, - 826, 827, 828, 1190, -1, -1, 2621, -1, -1, 3396, - 476, -1, 478, 479, 840, 841, -1, 843, -1, -1, - 292, -1, -1, 2871, 3411, -1, -1, 2817, 145, -1, - 856, 2148, -1, 3420, 101, 3422, 862, 3396, -1, 3396, - 3353, -1, -1, 3422, 176, -1, -1, 873, 2459, 515, - 876, 877, 518, 519, 520, -1, -1, -1, 3445, 3437, - 177, -1, -1, -1, -1, -1, -1, -1, 2185, 2186, - 202, 3437, 3459, 3460, 3461, -1, -1, 194, -1, 1613, - -1, -1, 199, 3396, -1, 3463, 3445, -1, 3445, -1, - -1, -1, -1, -1, -1, 921, 922, 3463, -1, 3486, - -1, 2716, -1, -1, -1, 2516, 173, -1, -1, -1, - 936, 937, 938, 939, 940, -1, -1, -1, 40, 251, - 237, -1, -1, -1, -1, -1, -1, 953, -1, 261, - -1, -1, 3445, -1, -1, -1, -1, -1, 60, -1, - 3527, 273, 209, -1, 504, 505, 506, -1, 508, 509, - 510, 511, 512, 513, -1, -1, -1, -1, 225, 985, - 986, -1, 988, -1, -1, 991, -1, -1, 235, -1, - -1, 997, 998, 305, -1, 292, -1, 1003, 2793, -1, - -1, -1, -1, 1009, 106, 107, -1, -1, -1, 1520, - 1016, -1, -1, -1, -1, 117, 2986, -1, -1, -1, - 1026, -1, 269, -1, -1, 172, -1, -1, -1, -1, - 2621, -1, -1, 1520, 13, -1, 1042, 1751, -1, 3009, - 19, -1, -1, 290, -1, -1, -1, 359, -1, 1416, - 1417, 30, 504, 505, 506, 1422, 508, 509, 510, 511, - 512, 513, -1, -1, -1, 44, 45, -1, 315, -1, - -1, -1, 384, -1, 176, 322, -1, -1, -1, -1, - -1, 8, -1, -1, 11, 1091, -1, -1, 15, 16, - -1, 403, 19, 20, 21, -1, -1, 394, -1, -1, - 202, -1, 1613, -1, -1, 2900, -1, -1, -1, 36, - 3138, -1, -1, -1, -1, -1, -1, 364, -1, 3089, - -1, -1, -1, -1, -1, 2716, 1613, -1, -1, -1, - 109, 3159, 3160, -1, -1, 1141, 383, -1, 1144, 2934, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 251, - -1, -1, 1158, 1159, -1, -1, 3184, 304, -1, 261, - 1166, -1, -1, -1, -1, -1, 2463, 2464, 315, 316, - 317, 273, -1, 275, -1, -1, -1, -1, -1, -1, - 1894, -1, -1, -1, 1190, -1, -1, -1, 3158, -1, - -1, -1, 1906, -1, 1200, 1201, -1, -1, -1, 0, - 1416, 1417, 2793, 305, 501, 452, 1422, 1213, -1, -1, - 457, 508, 509, 510, 511, 512, 513, -1, 3013, -1, - -1, -1, 1936, -1, 1230, -1, -1, -1, 1234, 1943, - -1, -1, -1, 1239, -1, 382, -1, -1, -1, -1, - 1751, -1, -1, -1, -1, -1, -1, -1, 37, -1, - -1, -1, -1, 42, -1, -1, -1, 359, -1, -1, - -1, 3056, -1, -1, 1751, 1979, -1, -1, -1, 1983, - -1, 41, 419, -1, -1, 1989, -1, -1, -1, -1, - -1, -1, 384, -1, -1, -1, -1, 1654, -1, 1295, - -1, 1297, -1, -1, -1, 222, -1, 1303, 2012, 100, - -1, 403, -1, 405, -1, 452, 408, -1, -1, 2900, - -1, 1317, 101, -1, -1, 3285, 463, 991, -1, -1, - 1326, -1, -1, -1, 2621, 1331, -1, 1333, 1334, -1, - 1336, 1337, 479, -1, -1, -1, -1, 1704, 108, -1, - 110, -1, 112, 2934, -1, -1, 147, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 503, -1, -1, -1, - -1, 162, -1, 3158, -1, 292, 167, -1, -1, -1, - 517, 172, -1, -1, -1, -1, -1, -1, -1, -1, - 181, -1, -1, 1894, 173, 186, -1, -1, 3416, 8, - -1, -1, 11, -1, -1, 1906, 15, 16, -1, -1, - 19, 20, 21, -1, -1, -1, -1, 1894, -1, -1, - 1416, 1417, -1, -1, -1, 517, 1422, 218, 1424, 1906, - 209, -1, 3013, -1, -1, 1936, -1, -1, -1, -1, - -1, 1437, 1943, 1439, 1440, -1, 225, 238, -1, -1, - -1, 1447, -1, -1, 1450, -1, 235, 1453, -1, 1936, - 3420, -1, 1458, -1, 2751, 1461, 1943, -1, -1, -1, - 1466, -1, 1468, -1, 1470, 3056, -1, -1, 1979, -1, - -1, -1, 1983, -1, -1, -1, -1, -1, 1989, -1, - 269, -1, -1, -1, -1, -1, 287, -1, -1, 290, - -1, -1, 1979, -1, -1, 296, 1983, -1, -1, -1, - -1, 2012, 1989, -1, -1, -1, -1, 1181, -1, -1, - -1, -1, -1, -1, -1, -1, 1190, -1, -1, -1, - -1, -1, -1, -1, -1, 2012, 315, -1, -1, -1, - -1, -1, -1, 322, -1, 336, -1, -1, -1, -1, - 1907, 1908, 1909, 1910, 1911, 1912, -1, -1, 1915, 1916, - 1917, 1918, 1919, 1920, 1921, 1922, 1923, 1924, -1, -1, - 361, -1, -1, -1, -1, -1, -1, 3158, 151, 1575, - -1, -1, -1, -1, -1, 364, 555, 504, 505, 506, - 1586, 508, 509, 510, 511, 512, 513, -1, -1, 172, - -1, -1, 2889, 8, 383, -1, 11, 2894, -1, -1, - 15, 16, -1, 222, -1, -1, -1, 151, -1, -1, - 2324, -1, -1, -1, 8, -1, -1, 11, 419, 1625, - -1, 15, 16, -1, -1, 3420, -1, -1, 172, -1, - -1, 46, -1, -1, -1, -1, -1, -1, 53, -1, - -1, -1, -1, -1, 2941, 2942, 447, -1, -1, -1, - 172, -1, 46, -1, -1, -1, 457, -1, -1, 53, - -1, -1, -1, 452, -1, 80, 1672, -1, 1674, -1, - 1676, -1, -1, 292, -1, 476, -1, 478, 479, -1, - -1, 1687, -1, 1689, 1690, 1691, 80, -1, -1, -1, - -1, 1907, 1908, 1909, 1910, 1911, 1912, -1, 1704, 1915, - 1916, 1917, 1918, 1919, 1920, 1921, 1922, 1923, 1924, -1, - -1, -1, -1, -1, 515, -1, -1, 518, 519, 520, - -1, -1, -1, 1729, -1, 1731, -1, 2094, 2095, -1, - 145, -1, 315, 316, 317, -1, -1, -1, -1, 1745, - 1746, -1, 1416, 1417, -1, 2459, -1, -1, 1422, -1, - 1756, 1757, 1758, 1759, -1, 1761, -1, -1, -1, -1, - -1, 1767, 177, 1769, -1, -1, -1, 746, 747, 539, - -1, 315, 316, 317, 544, 1781, 1782, 547, -1, 194, - 1786, 1787, -1, 177, 199, 1791, 1792, 1793, 1794, -1, - 1796, 1797, -1, 315, 316, 317, -1, -1, -1, 382, - 194, -1, 2516, -1, -1, 199, -1, 1813, -1, -1, - -1, -1, -1, 2324, -1, -1, 1822, 1823, 1824, 1825, - 1826, 1827, 237, -1, -1, -1, -1, -1, -1, 3420, - -1, -1, -1, -1, -1, 1841, 419, 2324, 382, -1, - -1, -1, -1, 237, -1, 2212, 0, -1, -1, 3146, - 3147, 1857, -1, -1, -1, -1, -1, -1, -1, -1, - 382, 3158, -1, -1, -1, -1, -1, -1, -1, 452, - -1, -1, -1, -1, -1, 419, -1, 292, 2094, 2095, - 463, -1, -1, 862, -1, 504, 505, 506, -1, 508, - 509, 510, 511, 512, 513, -1, 479, 419, 292, -1, - -1, 1907, 1908, 1909, 1910, 1911, 1912, 2621, 452, 1915, - 1916, 1917, 1918, 1919, 1920, 1921, 1922, 1923, 1924, 463, - 503, -1, -1, -1, -1, 178, -1, -1, -1, -1, - 452, -1, -1, -1, 517, 479, -1, -1, -1, 1945, - -1, 463, -1, -1, -1, -1, 100, -1, 2459, -1, - 203, 1957, -1, -1, -1, -1, -1, 479, -1, 503, - 1966, -1, -1, -1, -1, -1, 1972, -1, -1, -1, - -1, 1977, 2459, 517, -1, -1, 1982, -1, -1, 394, - -1, 503, -1, -1, -1, 1991, 1992, -1, 241, -1, - -1, -1, -1, 147, -1, 517, -1, -1, -1, -1, - 394, -1, 2716, -1, -1, 2516, -1, -1, 162, -1, - -1, -1, -1, 167, -1, -1, -1, -1, 172, -1, - -1, -1, -1, -1, 1003, 795, -1, 181, -1, 2516, - 1704, -1, 186, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 295, -1, -1, -1, -1, 1026, -1, -1, - -1, -1, -1, -1, -1, 8, 2062, -1, 11, -1, - 2066, 314, 15, 16, 218, 2071, 19, 20, 21, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 2793, - -1, -1, -1, 36, 238, -1, 501, -1, 2094, 2095, - -1, -1, -1, 508, 509, 510, 511, 512, 513, -1, - -1, -1, -1, 873, -1, 2111, -1, 501, -1, -1, - 2621, -1, 1091, -1, 508, 509, 510, 511, 512, 513, - 373, -1, -1, 3420, -1, -1, -1, 380, -1, -1, - -1, -1, -1, 287, 2621, -1, 290, -1, 2144, -1, - -1, -1, 296, -1, -1, -1, -1, -1, -1, -1, - 2156, 921, -1, 2520, 2521, 2161, -1, -1, -1, 2165, - -1, -1, -1, -1, -1, -1, 936, 937, 938, 939, - 423, -1, 425, -1, -1, -1, -1, -1, -1, 1158, - 1159, -1, 336, -1, -1, -1, 2900, -1, -1, 442, - -1, -1, -1, -1, -1, 448, -1, -1, 451, -1, - -1, -1, -1, 2209, -1, 2716, 2212, 361, -1, 2215, - -1, -1, -1, -1, -1, -1, -1, -1, 988, -1, - 2934, -1, -1, -1, -1, 2231, -1, -1, -1, 2716, - -1, -1, -1, 1907, 1908, 1909, 1910, 1911, 1912, -1, - -1, 1915, 1916, 1917, 1918, 1919, 1920, 1921, 1922, 1923, - 1924, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 419, -1, -1, -1, 222, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 2793, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 447, -1, -1, 2302, -1, -1, 3013, - -1, -1, 2308, 457, 2520, 2521, 2793, -1, -1, -1, - -1, -1, -1, -1, 2320, 2321, 2322, 2323, -1, -1, - -1, -1, 476, -1, 478, 479, -1, -1, 2334, -1, - 2336, -1, -1, 2339, -1, -1, -1, 2343, -1, 292, - -1, 2347, 3056, -1, -1, -1, 2713, 2353, -1, -1, - -1, -1, -1, -1, 1333, 1334, -1, 1336, -1, -1, - -1, 515, -1, -1, 518, 519, 520, 2373, 2374, -1, - 2376, 2738, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 2900, - -1, -1, -1, -1, 8, -1, -1, 11, -1, 2405, - -1, 15, 16, -1, -1, 19, 20, 21, -1, -1, - -1, -1, -1, 2900, -1, -1, -1, -1, -1, 2425, - 2094, 2095, -1, 2934, -1, -1, -1, 2433, 2434, 2435, - 1200, -1, -1, -1, -1, -1, 2442, -1, 2444, 2445, - -1, -1, -1, 1213, 3158, 2451, -1, 2934, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 1439, -1, -1, -1, 1234, 2471, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 8, -1, -1, 11, 2485, - -1, -1, 15, 16, 17, 18, 19, 20, 21, 1468, - -1, 1470, -1, -1, -1, -1, -1, 2713, -1, -1, - -1, -1, 3013, 36, -1, 2872, -1, -1, -1, -1, - -1, -1, -1, 46, 2520, 2521, -1, -1, -1, -1, - 53, -1, -1, -1, -1, -1, 3013, 1297, -1, -1, - -1, -1, -1, 1303, -1, -1, -1, -1, 2212, -1, - -1, -1, -1, 2549, -1, 3056, -1, 80, -1, 2555, - -1, 504, 505, 506, -1, 508, 509, 510, 511, 512, - 513, -1, -1, -1, -1, -1, -1, 2573, -1, 3056, - -1, 2577, -1, -1, -1, 2581, 2582, 2583, -1, -1, - -1, 2587, 2588, 2589, -1, 2591, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 2610, -1, 2612, -1, 222, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 2625, - 2626, 2627, 2628, 2629, 2630, 2631, 2632, 2633, 2634, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 177, 3012, -1, 3158, -1, -1, - -1, 2657, -1, -1, -1, -1, 2872, -1, 2664, -1, - -1, 194, -1, -1, -1, -1, 199, -1, 2674, -1, - -1, 3158, -1, -1, -1, -1, -1, 1447, 292, -1, - -1, -1, -1, -1, -1, -1, 2692, -1, -1, 222, - 223, -1, -1, -1, -1, -1, 2702, -1, -1, -1, - -1, -1, -1, -1, 237, -1, 3420, 2713, -1, -1, - -1, -1, -1, 2719, -1, -1, -1, -1, -1, -1, - 2726, 2727, 2728, 2729, -1, -1, -1, -1, -1, -1, - -1, -1, 2738, -1, -1, 2741, -1, -1, -1, 2745, - 2746, -1, 275, -1, -1, 278, -1, -1, 2754, 26, - -1, -1, 1731, -1, -1, 32, -1, -1, -1, 292, - -1, -1, 295, 40, -1, -1, -1, 1746, -1, -1, - -1, -1, -1, -1, -1, 2781, -1, 1756, -1, 1758, - -1, -1, 1761, 60, -1, -1, -1, -1, 1767, -1, - 1769, -1, -1, -1, -1, -1, 3012, -1, -1, -1, - -1, -1, -1, 1782, -1, 2811, -1, 2813, 1787, -1, - -1, -1, 1791, 1792, 1793, 1794, -1, 1796, 1797, -1, - -1, 2827, -1, -1, -1, 2831, -1, -1, -1, 106, - -1, 2837, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 2851, 2520, 2521, -1, -1, - -1, 2857, -1, -1, -1, 3222, -1, -1, -1, -1, - 137, 394, -1, -1, 2870, 2871, 2872, -1, -1, -1, - 3, -1, 2878, -1, -1, 8, -1, -1, 11, -1, - -1, -1, 15, 16, 17, 18, 19, 20, 21, 2895, - 504, 505, 506, -1, 508, 509, 510, 511, 512, 513, - -1, -1, -1, 36, 1674, -1, 1676, 40, -1, 3420, - -1, -1, -1, 46, -1, -1, -1, 1687, -1, -1, - 53, -1, -1, -1, -1, 202, -1, -1, -1, -1, - -1, -1, -1, 3420, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 80, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 1729, - -1, -1, -1, -1, -1, -1, 1945, 2973, 501, -1, - 2976, 504, 505, 506, 251, 508, 509, 510, 511, 512, - 513, -1, -1, 2989, 261, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 527, -1, 273, -1, 1977, 3005, - -1, -1, -1, 1982, -1, -1, 3012, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 294, -1, -1, - -1, -1, 8, -1, -1, 11, -1, -1, 305, 15, - 16, -1, 3038, 19, 20, 21, -1, -1, 3044, 2713, - -1, -1, -1, -1, 177, 3051, -1, -1, -1, -1, - -1, -1, 1822, 1823, 1824, 1825, -1, 1827, -1, -1, - 46, 194, -1, -1, 2738, -1, 199, 53, -1, -1, - -1, -1, -1, -1, -1, -1, 353, -1, -1, 3085, - 357, -1, 359, 2062, -1, -1, -1, -1, -1, 222, - 223, -1, 2071, -1, 80, -1, -1, -1, -1, -1, - -1, 3107, -1, -1, 237, -1, 3112, 384, 2782, -1, - -1, -1, 389, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 8, -1, -1, 11, 403, -1, -1, 15, - 16, -1, 3138, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 275, -1, -1, 278, -1, -1, -1, -1, - -1, -1, -1, 3159, 3160, -1, -1, -1, -1, 292, - 46, -1, 295, -1, -1, -1, -1, 53, -1, -1, - -1, -1, 3178, -1, 3180, -1, -1, 2156, 3184, -1, - -1, -1, -1, 460, -1, -1, -1, 1957, -1, -1, - -1, 177, -1, 3199, 80, -1, 3202, -1, 2872, -1, - -1, 838, 839, -1, -1, -1, -1, -1, 194, -1, - -1, -1, -1, 199, -1, -1, 3222, -1, -1, -1, - 3226, 3227, -1, 3229, -1, -1, -1, -1, -1, -1, - 2209, -1, -1, -1, -1, -1, 2215, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 3254, -1, - -1, 237, -1, -1, -1, 3261, -1, -1, -1, 145, - -1, 394, -1, -1, -1, -1, -1, -1, -1, 906, - -1, -1, -1, 910, 911, -1, 8, -1, -1, 11, - -1, -1, -1, 15, 16, -1, 3292, -1, -1, -1, - -1, 177, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 292, -1, 194, -1, - -1, -1, -1, 199, 46, -1, -1, -1, -1, -1, - -1, 53, -1, -1, -1, 3331, 963, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 3012, -1, - -1, -1, -1, -1, 981, -1, -1, 3353, 80, -1, - 987, 237, -1, 990, -1, 2334, 993, 994, 995, 996, - -1, -1, -1, -1, -1, -1, -1, -1, 501, -1, - -1, 504, 505, 506, 3380, 508, 509, 510, 511, 512, - 513, -1, -1, -1, -1, -1, -1, 3393, 3394, -1, - 3396, 3397, -1, -1, -1, -1, 1033, 1034, -1, 3405, - -1, -1, -1, -1, -1, -1, 292, -1, 394, -1, - 3416, -1, -1, 145, -1, 8, -1, 1054, 11, -1, - -1, -1, 15, 16, 17, 18, 19, 20, 21, -1, - -1, -1, 3438, -1, -1, -1, 1073, -1, -1, 3445, - -1, -1, -1, 36, -1, 177, -1, 1084, 1085, 1086, - -1, 1088, 1089, 46, -1, -1, -1, -1, -1, -1, - 53, -1, 194, 2442, -1, -1, 2445, 199, -1, -1, - -1, -1, 2451, -1, -1, -1, 3482, -1, -1, -1, - -1, -1, -1, -1, -1, 1122, -1, 80, -1, -1, - -1, 3497, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 1139, 1140, -1, 237, -1, -1, 394, -1, - -1, -1, -1, -1, -1, 501, -1, -1, 504, 505, - 506, -1, 508, 509, 510, 511, 512, 513, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 2308, 1176, - -1, -1, -1, 1180, 1181, -1, -1, -1, 3222, -1, - -1, 2321, 2322, 2323, 1191, 1192, -1, -1, -1, -1, - 292, -1, -1, -1, -1, -1, 2336, -1, -1, 2339, - -1, -1, -1, -1, -1, -1, -1, 2347, -1, -1, - -1, -1, -1, -1, 177, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 2577, -1, - -1, 194, 2581, 2582, 2583, -1, 199, -1, -1, -1, - 1247, -1, -1, -1, -1, 501, -1, -1, -1, 1256, - -1, -1, 508, 509, 510, 511, 512, 513, -1, 222, - 223, 2610, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 1280, 237, -1, 2625, 2626, 2627, 2628, - 2629, 2630, 2631, 2632, 2633, 2634, -1, -1, -1, -1, - -1, -1, 394, 2433, 2434, 2435, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 68, 69, -1, -1, -1, - -1, -1, 275, -1, -1, 278, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 292, - 0, -1, 295, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 109, 110, -1, -1, - 113, 114, 22, -1, -1, -1, -1, -1, -1, 1366, - -1, -1, 32, -1, 34, 35, -1, -1, -1, -1, - 2719, -1, -1, -1, -1, -1, -1, 47, -1, -1, - -1, -1, 52, -1, -1, -1, -1, -1, -1, -1, - -1, 61, -1, -1, -1, -1, 2745, -1, -1, 501, - -1, -1, -1, -1, -1, 75, 508, 509, 510, 511, - 512, 513, -1, -1, 84, -1, 86, -1, -1, -1, - -1, -1, 1429, -1, 1431, 1432, 189, 190, 98, -1, - 100, 394, -1, 2573, -1, -1, -1, 1444, 1445, -1, - -1, 111, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 1460, -1, -1, 126, 127, 128, -1, - -1, -1, -1, -1, -1, -1, -1, 137, -1, -1, - -1, -1, -1, 143, -1, -1, -1, -1, -1, -1, - -1, 151, -1, 153, 154, -1, -1, -1, -1, -1, - 253, 254, 255, 256, 257, 258, 259, 260, 168, -1, - 263, 264, 172, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 2871, -1, 2664, -1, -1, -1, 198, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 501, -1, - -1, 504, 505, 506, 214, 508, 509, 510, 511, 512, - 513, -1, -1, -1, 1561, -1, -1, -1, 521, -1, - -1, -1, 1569, -1, -1, -1, -1, -1, -1, -1, - 240, -1, -1, -1, 337, 338, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 2726, 2727, 2728, 2729, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 1608, -1, -1, -1, -1, -1, 1614, 1615, 1616, - 1617, 1618, 1619, 1620, 1621, 378, 379, -1, -1, 1626, - 1627, -1, -1, -1, 1631, -1, -1, -1, 1635, -1, - -1, 1638, 1639, 1640, 1641, 1642, 1643, 1644, 1645, 1646, - -1, -1, 1649, -1, -1, 315, 316, 317, -1, 1656, - -1, 1658, -1, 323, -1, -1, 326, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 1677, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 357, -1, -1, - -1, -1, -1, -1, -1, 3044, 366, -1, -1, -1, - -1, -1, 3051, -1, -1, -1, -1, -1, 1715, 1716, - 473, 474, 382, -1, -1, -1, -1, -1, -1, 389, - -1, -1, -1, 393, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 403, 497, 498, -1, -1, 2878, -1, - -1, -1, -1, -1, -1, 415, -1, -1, -1, 419, - -1, -1, -1, -1, 517, -1, -1, -1, 3107, 8, - -1, -1, 11, 3112, -1, -1, 15, 16, -1, 439, - 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 452, -1, -1, 455, -1, 36, 458, 3138, - -1, -1, -1, 463, -1, 1802, -1, 46, -1, 1806, - -1, -1, 1809, 1810, 53, -1, -1, -1, -1, 479, - 3159, 3160, -1, 8, -1, -1, 11, -1, -1, -1, - 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, - -1, 80, -1, 503, -1, 3184, -1, -1, -1, -1, - 1847, 36, -1, -1, -1, 40, -1, 517, -1, -1, - 520, 46, -1, -1, -1, -1, -1, -1, 53, -1, - -1, -1, 1869, 1870, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 3226, -1, -1, - -1, -1, -1, -1, -1, 80, -1, -1, -1, -1, - -1, 1898, 1899, -1, 1901, -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, 1930, 1931, -1, -1, 1934, 177, -1, - -1, 36, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 46, -1, -1, -1, 194, -1, -1, 53, -1, - 199, -1, -1, -1, -1, -1, 1963, -1, -1, -1, - -1, 1968, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 222, 223, 80, -1, -1, 1985, -1, - 1987, -1, 177, -1, -1, -1, -1, -1, 237, -1, - -1, -1, -1, -1, -1, -1, -1, 991, -1, 194, - -1, 26, -1, -1, 199, -1, -1, 32, -1, -1, - -1, -1, -1, -1, -1, 40, -1, -1, 2025, -1, - -1, -1, -1, -1, -1, -1, 275, 222, 223, 278, - -1, -1, -1, -1, -1, 60, -1, -1, 3178, -1, - -1, -1, 237, 292, -1, -1, 295, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 2064, -1, 3199, - -1, -1, 2069, 2070, -1, -1, -1, 3416, -1, -1, - -1, -1, 177, -1, -1, -1, -1, -1, -1, -1, - 275, 106, -1, 278, -1, -1, -1, -1, -1, 194, - -1, -1, -1, -1, 199, -1, -1, 292, -1, -1, - 295, -1, -1, -1, -1, -1, 2113, -1, -1, 2116, - -1, 2118, 137, -1, -1, 1109, -1, 222, 223, -1, - -1, 3261, -1, -1, -1, -1, -1, 2134, -1, -1, - -1, -1, 237, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 394, -1, -1, -1, -1, - -1, -1, 3292, -1, -1, -1, -1, -1, -1, -1, - 1154, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 275, 2178, -1, 278, -1, -1, -1, 202, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 292, 2195, 2196, - 295, -1, -1, -1, -1, -1, 1190, -1, -1, 394, - -1, -1, -1, -1, -1, -1, -1, 2214, -1, -1, - -1, -1, -1, -1, -1, -1, 2223, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 251, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 261, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 1241, 273, -1, - -1, -1, 501, -1, -1, 504, 505, 506, -1, 508, - 509, 510, 511, 512, 513, -1, -1, -1, -1, 294, - -1, -1, -1, 2280, -1, -1, -1, -1, -1, 2286, - 305, -1, -1, -1, -1, -1, -1, -1, -1, 394, - -1, 1285, -1, -1, -1, -1, 1290, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 501, -1, -1, 504, - 505, 506, -1, 508, 509, 510, 511, 512, 513, -1, - -1, -1, -1, 518, -1, -1, -1, -1, 353, -1, - 8, -1, 357, 11, 359, 2342, -1, 15, 16, 17, - 18, 19, 20, 21, -1, -1, 1340, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 36, 384, - -1, -1, -1, -1, 389, -1, -1, -1, 46, -1, - 1364, -1, -1, -1, -1, 53, -1, -1, 403, -1, - -1, -1, -1, -1, 3, -1, 5, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 501, -1, -1, 504, - 505, 506, 80, 508, 509, 510, 511, 512, 513, -1, - -1, -1, -1, 518, -1, -1, -1, -1, 1412, -1, - 1414, -1, 1416, 1417, -1, 1419, -1, -1, 1422, -1, - -1, 1425, -1, -1, 1428, 460, -1, -1, -1, 1433, - -1, -1, 1436, -1, -1, -1, -1, -1, -1, 68, - 69, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 68, 69, -1, -1, -1, -1, -1, 2476, - -1, -1, -1, -1, -1, 2482, 2483, -1, -1, 1473, - -1, -1, -1, -1, -1, -1, 2493, -1, -1, -1, - 109, 110, -1, -1, 113, 114, -1, 2504, -1, 177, - 2507, -1, 2509, 109, 110, -1, -1, 113, 114, -1, - 2517, -1, -1, -1, -1, -1, 194, -1, 2525, 2526, - -1, 199, -1, -1, -1, 2532, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 2547, -1, -1, -1, 222, 223, -1, -1, -1, -1, - 2557, -1, -1, -1, -1, -1, -1, -1, -1, 237, - -1, -1, -1, 1557, -1, -1, -1, -1, -1, -1, - 189, 190, 2579, -1, -1, -1, -1, -1, -1, 1573, - -1, -1, -1, 189, 190, -1, -1, -1, -1, 1583, - 1584, 1585, -1, -1, -1, 1589, -1, 275, -1, 1593, - 278, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 292, -1, -1, 295, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 2636, - -1, 2638, -1, -1, 253, 254, 255, 256, 257, 258, - 259, 260, -1, -1, 263, 264, -1, 253, 254, 255, - 256, 257, 258, 259, 260, -1, -1, 263, 264, -1, - -1, 1655, -1, -1, -1, -1, -1, 8, -1, -1, - 11, -1, -1, -1, 15, 16, 17, 18, 19, 20, - 21, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 36, -1, -1, -1, -1, - -1, -1, -1, -1, 1698, 46, -1, -1, -1, -1, - -1, -1, 53, -1, -1, -1, 394, -1, 337, 338, - 1714, -1, -1, -1, -1, 1719, 2733, 2734, -1, -1, - -1, 337, 338, -1, -1, -1, -1, -1, -1, 80, - -1, -1, 1736, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 378, - 379, 2768, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 8, 378, 379, 11, 2782, -1, -1, 15, 16, - 2787, 2788, 19, 20, 21, 2792, -1, -1, -1, -1, - 2797, -1, -1, 2800, 2801, -1, -1, -1, 2805, 2806, - -1, -1, 2809, -1, -1, -1, -1, -1, -1, 46, - -1, -1, -1, 2820, -1, -1, 53, -1, -1, -1, - -1, -1, -1, 501, -1, -1, 504, 505, 506, -1, - 508, 509, 510, 511, 512, 513, 177, -1, -1, -1, - 518, -1, -1, 80, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 194, 473, 474, -1, 2864, 199, -1, - -1, -1, -1, -1, -1, -1, -1, 473, 474, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 497, 498, - -1, 222, 223, -1, 2891, -1, -1, -1, -1, -1, - -1, 497, 498, -1, -1, -1, 237, -1, -1, -1, - -1, -1, 1896, -1, -1, -1, -1, -1, -1, -1, - 1904, 1905, -1, 1907, 1908, 1909, 1910, 1911, 1912, -1, - -1, 1915, 1916, 1917, 1918, 1919, 1920, 1921, 1922, 1923, - 1924, 1925, -1, -1, 275, -1, -1, 278, -1, -1, - 177, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 292, -1, -1, 295, -1, -1, 194, -1, -1, - -1, -1, 199, -1, -1, -1, -1, 8, -1, -1, - 11, -1, -1, 2980, 15, 16, 17, 18, 19, 20, - 21, -1, -1, -1, -1, 222, 223, -1, -1, -1, - -1, -1, -1, -1, -1, 36, -1, -1, -1, -1, - 237, -1, -1, -1, -1, 46, -1, -1, -1, -1, - -1, -1, 53, -1, -1, -1, -1, -1, -1, -1, - -1, 3028, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 2028, -1, -1, 2031, 275, 80, - -1, 278, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 394, 3061, 292, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 3072, 3073, -1, -1, 3076, - -1, 3078, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 2077, -1, -1, -1, 2081, 2082, 2083, - 2084, 2085, 2086, 2087, 2088, -1, 3103, -1, -1, -1, - 2094, 2095, -1, 2097, 2098, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 2109, -1, -1, 2112, -1, - 3127, -1, -1, -1, -1, -1, 2120, 2121, 2122, 2123, - 2124, 2125, 2126, 2127, 2128, 2129, 177, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 194, -1, -1, -1, 394, 199, -1, - 501, 2155, -1, 504, 505, 506, -1, 508, 509, 510, - 511, 512, 513, -1, -1, -1, -1, 518, -1, -1, - -1, 222, 223, -1, -1, -1, -1, -1, -1, -1, - 3197, -1, -1, -1, -1, -1, 237, -1, -1, -1, - -1, -1, -1, -1, -1, 24, -1, -1, -1, 3216, - -1, -1, -1, 3220, -1, -1, -1, 3224, 2212, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 3235, -1, - -1, -1, -1, 3240, 275, 3242, -1, 278, -1, -1, - -1, -1, -1, 3250, -1, -1, -1, -1, -1, -1, - -1, 292, -1, -1, 295, -1, -1, -1, -1, -1, - -1, 3268, 81, -1, 501, -1, -1, 504, 505, 506, - -1, 508, 509, 510, 511, 512, 513, -1, 97, -1, - -1, -1, -1, -1, -1, -1, -1, 2281, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 2291, 2292, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 3317, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 3327, -1, -1, -1, -1, -1, -1, 146, -1, -1, - -1, -1, 3339, -1, -1, -1, -1, 156, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 169, -1, -1, 394, -1, 174, -1, -1, -1, -1, - -1, -1, 2356, -1, 3371, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 203, -1, 2380, 2381, 2382, -1, - -1, 2385, 2386, 2387, 2388, 2389, 2390, -1, -1, -1, - 2394, 2395, 2396, 2397, 2398, 2399, 2400, 2401, 2402, 2403, - 8, -1, -1, 11, 2408, 2409, -1, 15, 16, 17, - 18, 19, 20, 21, -1, -1, -1, 246, -1, -1, - -1, 250, -1, -1, -1, -1, -1, -1, 36, -1, - -1, -1, 2436, -1, -1, -1, -1, 2441, 46, -1, - -1, -1, 3459, 3460, 3461, 53, -1, -1, -1, -1, - 501, -1, -1, 504, 505, 506, -1, 508, 509, 510, - 511, 512, 513, -1, -1, -1, -1, 518, -1, 3486, - -1, 2475, 80, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 2494, 320, -1, 2497, 2498, -1, -1, -1, -1, -1, - -1, 2505, 2506, -1, -1, -1, 335, -1, -1, -1, - 3527, -1, -1, -1, -1, 2519, 2520, 2521, 2522, -1, - 2524, -1, -1, -1, 2528, -1, 8, -1, -1, 11, - -1, -1, -1, 15, 16, 17, 18, 19, 20, 21, - -1, 370, -1, -1, 373, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 36, 384, -1, -1, 387, -1, - -1, -1, -1, -1, 46, -1, -1, -1, -1, 177, - -1, 53, -1, -1, -1, -1, 405, -1, -1, -1, - 2584, -1, -1, -1, -1, -1, 194, -1, -1, -1, - 419, 199, -1, 8, -1, -1, 11, 426, 80, -1, - 15, 16, 17, 18, 19, 20, 21, 436, -1, -1, - -1, -1, -1, 442, 222, 223, -1, -1, -1, -1, - -1, 36, -1, -1, -1, -1, -1, -1, -1, 237, - -1, 46, -1, -1, -1, -1, -1, -1, 53, -1, - 469, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 80, -1, 275, -1, -1, - 278, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 292, 2689, -1, 295, -1, -1, - -1, -1, -1, -1, -1, 177, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 2713, - -1, -1, 194, -1, -1, -1, -1, 199, -1, -1, - -1, -1, -1, -1, -1, 8, -1, -1, 11, -1, - -1, -1, 15, 16, 17, 18, 19, 20, 21, -1, - 222, 223, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 36, -1, 237, -1, -1, 41, -1, - -1, -1, 177, 46, -1, 2769, -1, 2771, -1, -1, - 53, -1, -1, 2777, -1, -1, -1, -1, -1, 194, - -1, -1, 2786, -1, 199, 2789, 394, 2791, -1, -1, - -1, 2795, -1, 275, 2798, 2799, 278, 80, 2802, 2803, - -1, -1, -1, -1, -1, -1, 2810, 222, 223, -1, - 292, -1, -1, 295, -1, 2819, -1, -1, -1, -1, - -1, -1, 237, -1, -1, -1, -1, -1, -1, -1, - 2834, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 126, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 24, -1, -1, -1, - 275, -1, -1, 278, -1, -1, -1, -1, 2872, -1, - -1, -1, -1, -1, -1, -1, -1, 292, -1, -1, - 295, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 501, 177, -1, 504, 505, 506, -1, - 508, 509, 510, 511, 512, 513, -1, -1, -1, -1, - 518, 194, 394, 81, -1, -1, 199, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 97, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 222, - 223, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 237, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 146, 394, - -1, -1, -1, -1, -1, -1, -1, -1, 156, -1, - -1, -1, 275, -1, -1, 278, -1, -1, -1, -1, - -1, 169, -1, -1, -1, -1, 174, 3011, 3012, 292, - -1, -1, 295, -1, -1, -1, -1, -1, -1, 501, - -1, -1, 504, 505, 506, -1, 508, 509, 510, 511, - 512, 513, 3036, 3037, -1, 203, 518, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 3060, -1, -1, -1, - 3064, -1, 3066, 3067, 3068, -1, -1, 3071, -1, -1, - 3074, 3075, -1, -1, -1, -1, -1, -1, 246, 3083, - -1, -1, 250, -1, -1, -1, 501, -1, -1, 504, - 505, 506, -1, 508, 509, 510, 511, 512, 513, -1, - -1, -1, -1, 518, -1, -1, -1, -1, -1, -1, - -1, 394, -1, -1, -1, -1, -1, -1, -1, -1, - 3124, -1, -1, -1, -1, -1, 3130, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 3143, - -1, -1, -1, -1, -1, -1, 314, -1, -1, -1, - -1, -1, 320, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 335, -1, -1, - -1, -1, 3176, -1, 457, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 3204, -1, 370, -1, -1, 373, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 384, -1, 501, 387, - -1, 504, 505, 506, -1, 508, 509, 510, 511, 512, - 513, -1, -1, 3237, 3238, 3239, -1, 405, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 419, -1, 3257, -1, -1, -1, 425, 426, -1, - -1, -1, -1, -1, -1, 3269, -1, -1, 436, -1, - -1, -1, -1, -1, 442, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 469, -1, -1, -1, -1, -1, -1, -1, -1, - 3314, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 3332, -1, - -1, -1, -1, -1, -1, -1, -1, 3341, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 3366, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 3392, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 3, 4, 5, 6, 7, 8, - 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 3435, -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, 3489, 75, 76, 77, 78, - 79, -1, 81, -1, 83, 84, 85, 86, 87, 88, - 89, 90, 91, 92, -1, 94, 95, 96, 97, 98, - 99, -1, 101, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, - -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, - 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, - -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, - 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, 160, 161, -1, 163, 164, 165, 166, -1, 168, - -1, 170, 171, -1, 173, 174, 175, 176, 177, 178, - -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, - 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, - -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, - 209, 210, 211, 212, 213, 214, 215, 216, 217, -1, - 219, -1, 221, 222, 223, 224, 225, 226, 227, 228, - 229, 230, 231, -1, -1, 234, 235, 236, 237, -1, - 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, - 279, 280, 281, 282, 283, 284, 285, 286, -1, 288, - 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, - 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, - 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, - 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, - 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, - 379, 380, 381, -1, -1, 384, 385, 386, 387, 388, - 389, 390, 391, 392, -1, 394, 395, 396, 397, 398, - -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, - -1, 420, 421, 422, 423, 424, 425, 426, -1, 428, - 429, 430, -1, -1, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, - 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, - 459, 460, 461, 462, 463, 464, -1, 466, 467, 468, - 469, 470, 471, 472, 473, 474, -1, -1, 477, -1, - -1, 480, 481, 482, 483, 484, 485, 486, 487, 488, - 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, - 499, 500, 501, -1, -1, -1, -1, -1, -1, 508, - 509, 510, -1, -1, -1, -1, 515, -1, 517, -1, - -1, -1, -1, 522, 523, -1, 525, 526, 527, 3, - 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, - 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, - -1, -1, -1, -1, -1, 39, -1, -1, 42, 43, - 44, -1, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, -1, 59, 60, 61, 62, 63, - 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, - -1, 75, 76, 77, 78, 79, -1, 81, -1, 83, - 84, 85, 86, 87, 88, 89, 90, 91, 92, -1, - 94, 95, 96, 97, 98, 99, -1, 101, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 114, 115, 116, 117, 118, -1, 120, 121, 122, 123, - 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, - 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, - 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, 160, 161, -1, 163, - 164, 165, 166, -1, 168, -1, 170, 171, -1, 173, - 174, 175, 176, 177, 178, -1, 180, -1, 182, 183, - 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, - 194, 195, 196, 197, 198, -1, 200, 201, 202, 203, - 204, 205, 206, -1, 208, 209, 210, 211, 212, 213, - 214, 215, 216, 217, -1, 219, -1, 221, 222, 223, - 224, 225, 226, 227, 228, 229, 230, 231, -1, -1, - 234, 235, 236, 237, -1, 239, 240, 241, 242, 243, - 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, - 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, - 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, - 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, - 294, -1, -1, 297, 298, 299, 300, 301, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, -1, -1, -1, -1, 319, 320, 321, 322, 323, - 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, - 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, - 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, - 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, - 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, - 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, - 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, -1, -1, 417, 418, -1, 420, 421, 422, 423, - 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, - 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, - 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, - 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, - 464, -1, 466, 467, 468, 469, 470, 471, 472, 473, - 474, -1, -1, 477, -1, -1, 480, 481, 482, 483, - 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, - 494, 495, 496, 497, 498, 499, 500, 501, -1, -1, - -1, -1, -1, -1, 508, 509, 510, -1, -1, -1, - -1, 515, -1, 517, -1, -1, -1, -1, 522, 523, - -1, 525, 526, 527, 3, 4, 5, 6, 7, 8, - 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, - 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, - 39, -1, -1, 42, 43, 44, -1, 46, 47, 48, - 49, 50, 51, 52, 53, 54, 55, 56, 57, -1, - 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, - 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, - 79, -1, 81, -1, 83, 84, 85, 86, 87, 88, - 89, 90, 91, 92, -1, 94, 95, 96, 97, 98, - 99, -1, 101, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, - -1, 120, 121, 122, 123, 124, 125, 126, 127, 128, - 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, - -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, - 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, 160, 161, -1, 163, 164, 165, 166, -1, 168, - -1, 170, 171, 172, 173, 174, 175, 176, 177, 178, - -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, - 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, - -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, - 209, 210, 211, 212, 213, 214, 215, 216, 217, -1, - 219, -1, 221, 222, 223, 224, 225, 226, 227, 228, - 229, 230, 231, -1, -1, 234, 235, 236, 237, -1, - 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, - 279, 280, 281, 282, 283, 284, 285, 286, -1, 288, - 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, - 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, -1, - 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, - 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, - 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, - 379, 380, 381, 382, -1, 384, 385, 386, 387, 388, - 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, - -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, 412, 413, 414, 415, -1, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 426, -1, 428, - 429, 430, -1, -1, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, - 449, 450, 451, 452, 453, 454, 455, 456, -1, 458, - 459, 460, 461, 462, 463, 464, -1, 466, 467, 468, - 469, 470, 471, 472, 473, 474, -1, -1, 477, -1, - 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, - 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, - 499, 500, 501, -1, 503, -1, -1, -1, -1, 508, - 509, 510, -1, -1, -1, -1, 515, -1, 517, 518, - -1, -1, -1, 522, 523, -1, 525, 526, 3, 4, - 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, - 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, - -1, -1, -1, -1, 39, -1, -1, 42, 43, 44, - -1, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, -1, 59, 60, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, -1, - 75, 76, 77, 78, 79, -1, 81, -1, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, -1, 94, - 95, 96, 97, 98, 99, -1, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, -1, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, -1, -1, 134, - 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, - 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, -1, 163, 164, - 165, 166, -1, 168, -1, 170, 171, 172, 173, 174, - 175, 176, 177, 178, -1, 180, -1, 182, 183, 184, - 185, -1, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, - 205, 206, -1, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, -1, 219, -1, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, -1, -1, 234, - 235, 236, 237, -1, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, - -1, -1, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, -1, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, - 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, - 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, -1, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, 379, 380, 381, 382, -1, 384, - 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, - 415, -1, 417, 418, 419, 420, 421, 422, 423, 424, - 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, - 445, 446, -1, -1, 449, 450, 451, 452, 453, 454, - 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, - -1, 466, 467, 468, 469, 470, 471, 472, 473, 474, - -1, -1, 477, -1, 479, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 499, 500, 501, -1, 503, -1, - -1, -1, -1, 508, 509, 510, -1, -1, -1, -1, - 515, -1, 517, -1, -1, -1, -1, 522, 523, -1, - 525, 526, 3, 4, 5, 6, 7, 8, 9, 10, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, - 31, 32, 33, -1, -1, -1, -1, -1, 39, -1, - -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, - 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, - 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, - 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, - 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, - 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, - 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, 117, 118, -1, 120, - 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, - 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, - 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, - 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, - 171, 172, 173, 174, 175, 176, 177, 178, -1, 180, - -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, - 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, - 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, - 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, - 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, - 231, -1, -1, 234, 235, 236, 237, -1, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, - -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, -1, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, - 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, - 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, - 381, 382, -1, 384, 385, 386, 387, 388, 389, 390, - 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, -1, -1, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, - -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, - 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, - 451, 452, 453, 454, 455, 456, -1, 458, 459, 460, - 461, 462, 463, 464, -1, 466, 467, 468, 469, 470, - 471, 472, 473, 474, -1, -1, 477, -1, 479, 480, - 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, - 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, - 501, -1, 503, -1, -1, -1, -1, 508, 509, 510, - -1, -1, -1, -1, 515, -1, 517, -1, -1, -1, - -1, 522, 523, -1, 525, 526, 3, 4, 5, 6, - 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, -1, -1, -1, - 37, -1, 39, -1, -1, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, 132, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, - 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - 237, -1, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, 383, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, 465, 466, - 467, 468, 469, 470, 471, 472, 473, 474, -1, -1, - 477, -1, -1, 480, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, -1, -1, -1, -1, -1, - -1, 508, 509, 510, -1, -1, -1, -1, 515, -1, - 517, 518, -1, -1, -1, 522, 523, -1, 525, 526, - 3, 4, 5, 6, 7, -1, 9, 10, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, - 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, - 33, -1, -1, -1, -1, -1, 39, -1, -1, 42, - 43, 44, -1, 46, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, -1, 59, 60, 61, 62, - 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, - 73, -1, 75, 76, 77, 78, 79, -1, 81, -1, - 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, - -1, 94, 95, 96, 97, 98, 99, -1, 101, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, - 123, 124, 125, 126, 127, 128, 129, 130, 131, -1, - -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, - -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, -1, - 163, 164, 165, 166, -1, 168, -1, 170, 171, 172, - 173, 174, 175, 176, 177, 178, -1, 180, -1, 182, - 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, -1, 200, 201, 202, - 203, 204, 205, 206, -1, 208, 209, 210, 211, 212, - 213, 214, 215, 216, 217, -1, 219, -1, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, 231, -1, - -1, 234, 235, 236, 237, -1, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, -1, 276, 277, 278, 279, 280, 281, 282, - 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, - 293, 294, -1, -1, 297, 298, 299, 300, 301, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, -1, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, - 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, - -1, 384, 385, 386, 387, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, -1, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, -1, 417, 418, 419, 420, 421, 422, - 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, - 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, - 443, 444, 445, 446, -1, -1, 449, 450, 451, 452, - 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, - 463, 464, -1, 466, 467, 468, 469, 470, 471, 472, - 473, 474, -1, -1, 477, -1, 479, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 498, 499, 500, -1, -1, - 503, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 515, -1, 517, -1, -1, -1, -1, 522, - 523, -1, 525, 526, 3, 4, 5, 6, 7, 8, - 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, - 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, - 39, -1, -1, 42, 43, 44, -1, 46, 47, 48, - 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, - 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, - 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, - 79, -1, 81, -1, 83, 84, 85, 86, 87, 88, - 89, 90, 91, 92, -1, 94, 95, 96, 97, 98, - 99, -1, 101, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, - -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, - 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, - -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, - 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, 160, 161, -1, 163, 164, 165, 166, -1, 168, - -1, 170, 171, 172, 173, 174, 175, 176, 177, 178, - -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, - 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, - -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, - 209, 210, 211, 212, 213, 214, 215, 216, 217, -1, - 219, -1, 221, 222, 223, 224, 225, 226, 227, 228, - 229, 230, 231, -1, 233, 234, 235, 236, 237, -1, - 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, - 279, 280, 281, 282, 283, 284, 285, 286, -1, 288, - 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, - 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, - 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, - 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, - 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, - 379, 380, 381, -1, -1, 384, 385, 386, 387, 388, - 389, 390, 391, 392, -1, 394, 395, 396, 397, 398, - -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, - -1, 420, 421, 422, 423, 424, 425, 426, -1, 428, - 429, 430, -1, 432, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, - 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, - 459, 460, 461, 462, 463, 464, -1, 466, 467, 468, - 469, 470, 471, 472, 473, 474, -1, -1, 477, -1, - -1, 480, 481, 482, 483, 484, 485, 486, 487, 488, - 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, - 499, 500, 501, -1, -1, -1, -1, -1, -1, 508, - 509, 510, -1, -1, -1, -1, 515, -1, 517, -1, - -1, -1, -1, 522, 523, -1, 525, 526, 3, 4, - 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, - 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, - -1, -1, 37, -1, 39, -1, -1, 42, 43, 44, - -1, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, -1, 59, 60, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, -1, - 75, 76, 77, 78, 79, -1, 81, -1, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, -1, 94, - 95, 96, 97, 98, 99, -1, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, -1, 120, 121, 122, 123, 124, - 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, - 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, - 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, -1, 163, 164, - 165, 166, -1, 168, -1, 170, 171, -1, 173, 174, - 175, 176, 177, 178, -1, 180, -1, 182, 183, 184, - 185, -1, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, - 205, 206, -1, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, -1, 219, -1, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, -1, -1, 234, - 235, 236, 237, -1, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, - -1, -1, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - -1, -1, -1, -1, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, - 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, - 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, -1, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, 379, 380, 381, -1, 383, 384, - 385, 386, 387, 388, 389, 390, 391, 392, -1, 394, - 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, - -1, -1, 417, 418, -1, 420, 421, 422, 423, 424, - 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, - 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, - 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, - 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, - -1, -1, 477, -1, -1, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 499, 500, 501, -1, -1, -1, - -1, -1, -1, 508, 509, 510, -1, -1, -1, -1, - 515, -1, 517, -1, -1, -1, -1, 522, 523, -1, - 525, 526, 3, 4, 5, 6, 7, 8, 9, 10, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, - 31, 32, 33, -1, -1, -1, 37, -1, 39, -1, - -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, - 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, - 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, - 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, - 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, - 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, - 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, 117, 118, -1, 120, - 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, - 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, - 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, - 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, - 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, - -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, - 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, - 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, - 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, - 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, - 231, -1, -1, 234, 235, 236, 237, -1, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, - -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, - 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, - 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, - 381, -1, 383, 384, 385, 386, 387, 388, 389, 390, - 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, - 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, - -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, - 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, - 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, - 461, 462, 463, 464, -1, 466, 467, 468, 469, 470, - 471, 472, 473, 474, -1, -1, 477, -1, -1, 480, - 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, - 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, - 501, -1, -1, -1, -1, -1, -1, 508, 509, 510, - -1, -1, -1, -1, 515, -1, 517, 518, -1, -1, - -1, 522, 523, -1, 525, 526, 3, 4, 5, 6, - 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, -1, -1, -1, - -1, 38, 39, -1, -1, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, - 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - 237, -1, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, - 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, -1, 466, - 467, 468, 469, 470, 471, 472, 473, 474, -1, -1, - 477, -1, -1, 480, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, -1, -1, -1, -1, -1, - -1, 508, 509, 510, -1, -1, -1, -1, 515, -1, - 517, -1, -1, -1, -1, 522, 523, -1, 525, 526, - 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, - 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, - 33, -1, -1, -1, 37, -1, 39, -1, -1, 42, - 43, 44, -1, 46, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, -1, 59, 60, 61, 62, - 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, - 73, -1, 75, 76, 77, 78, 79, -1, 81, -1, - 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, - -1, 94, 95, 96, 97, 98, 99, -1, 101, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, 117, 118, -1, 120, 121, 122, - 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, - -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, - -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, -1, - 163, 164, 165, 166, -1, 168, -1, 170, 171, -1, - 173, 174, 175, 176, 177, 178, -1, 180, -1, 182, - 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, -1, 200, 201, 202, - 203, 204, 205, 206, -1, 208, 209, 210, 211, 212, - 213, 214, 215, 216, 217, -1, 219, -1, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, 231, -1, - -1, 234, 235, 236, 237, -1, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, - 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, - 293, 294, -1, -1, 297, 298, 299, 300, 301, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, -1, -1, -1, -1, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, - 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, - 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, - -1, 394, 395, 396, 397, 398, -1, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, -1, -1, 417, 418, -1, 420, 421, 422, - 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, - 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, - 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, - 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, - 463, 464, -1, 466, 467, 468, 469, 470, 471, 472, - 473, 474, -1, -1, 477, -1, -1, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 498, 499, 500, 501, -1, - -1, -1, -1, -1, -1, 508, 509, 510, -1, -1, - -1, -1, 515, -1, 517, 518, -1, -1, -1, 522, - 523, -1, 525, 526, 3, 4, 5, 6, 7, 8, - 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, - 29, -1, 31, 32, 33, -1, -1, -1, 37, -1, - 39, -1, -1, 42, 43, 44, -1, 46, 47, 48, - 49, 50, 51, 52, 53, 54, 55, 56, 57, -1, - 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, - 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, - 79, -1, 81, -1, 83, 84, 85, 86, 87, 88, - 89, 90, 91, 92, -1, 94, 95, 96, 97, 98, - 99, -1, 101, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, - -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, - 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, - -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, - 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, 160, 161, -1, 163, 164, 165, 166, -1, 168, - -1, 170, 171, -1, 173, 174, 175, 176, 177, 178, - -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, - 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, - -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, - 209, 210, 211, 212, 213, 214, 215, 216, 217, -1, - 219, -1, 221, 222, 223, 224, 225, 226, 227, 228, - 229, 230, 231, -1, -1, 234, 235, 236, 237, -1, - 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, - 279, 280, 281, 282, 283, 284, 285, 286, -1, 288, - 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, - 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, - 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, - 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, - 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, - 379, 380, 381, -1, 383, 384, 385, 386, 387, 388, - 389, 390, 391, 392, -1, 394, 395, 396, 397, 398, - -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, - -1, 420, 421, 422, 423, 424, 425, 426, -1, 428, - 429, 430, -1, -1, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, - 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, - 459, 460, 461, 462, 463, 464, -1, 466, 467, 468, - 469, 470, 471, 472, 473, 474, -1, -1, 477, -1, - -1, 480, 481, 482, 483, 484, 485, 486, 487, 488, - 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, - 499, 500, 501, -1, -1, -1, -1, -1, -1, 508, - 509, 510, -1, -1, -1, -1, 515, -1, 517, -1, - -1, -1, -1, 522, 523, -1, 525, 526, 3, 4, - 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, -1, - -1, -1, -1, -1, 39, -1, -1, 42, 43, 44, - -1, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, -1, 59, 60, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, -1, - 75, 76, 77, 78, 79, -1, 81, -1, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, -1, 94, - 95, 96, 97, 98, 99, -1, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, -1, 120, 121, 122, 123, 124, - 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, - 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, - 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, -1, 163, 164, - 165, 166, -1, 168, -1, 170, 171, -1, 173, 174, - 175, 176, 177, 178, -1, 180, -1, 182, 183, 184, - 185, -1, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, - 205, 206, -1, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, -1, 219, -1, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, -1, -1, 234, - 235, 236, 237, -1, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, - -1, -1, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - -1, -1, -1, -1, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, - 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, - 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, -1, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, - 385, 386, 387, 388, 389, 390, 391, 392, -1, 394, - 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, - -1, -1, 417, 418, -1, 420, 421, 422, 423, 424, - 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, - 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, - 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, - -1, 466, 467, 468, 469, 470, 471, 472, 473, 474, - -1, -1, 477, -1, -1, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 499, 500, 501, -1, -1, -1, - -1, -1, -1, 508, 509, 510, -1, -1, -1, -1, - 515, -1, 517, -1, -1, -1, -1, 522, 523, -1, - 525, 526, 3, 4, 5, 6, 7, 8, 9, 10, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 22, 23, 24, 25, 26, 27, 28, 29, 30, - 31, 32, 33, -1, -1, -1, -1, -1, 39, -1, - -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, - 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, - 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, - 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, - 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, - 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, - 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, 117, 118, -1, 120, - 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, - 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, - 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, - 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, - 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, - -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, - 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, - 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, - 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, - 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, - 231, -1, -1, 234, 235, 236, 237, -1, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, - -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, - 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, - 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, - 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, - 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, - 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, - -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, - 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, - 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, - 461, 462, 463, 464, -1, 466, 467, 468, 469, 470, - 471, 472, 473, 474, -1, -1, 477, -1, -1, 480, - 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, - 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, - 501, -1, -1, -1, -1, -1, -1, 508, 509, 510, - -1, -1, -1, -1, 515, -1, 517, -1, -1, -1, - -1, 522, 523, -1, 525, 526, 3, 4, 5, 6, - 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - -1, -1, 39, -1, -1, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, 172, 173, 174, 175, 176, - 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - 237, -1, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, -1, 466, - 467, 468, 469, 470, 471, 472, 473, 474, -1, -1, - 477, -1, -1, 480, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, -1, -1, -1, -1, -1, - -1, 508, 509, 510, -1, -1, -1, -1, 515, -1, - 517, -1, -1, -1, -1, 522, 523, -1, 525, 526, - 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, - 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, - 33, -1, -1, -1, -1, -1, 39, -1, -1, 42, - 43, 44, -1, 46, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, -1, 59, 60, 61, 62, - 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, - 73, -1, 75, 76, 77, 78, 79, -1, 81, -1, - 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, - -1, 94, 95, 96, 97, 98, 99, -1, 101, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, 117, 118, -1, 120, 121, 122, - 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, - -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, - -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, -1, - 163, 164, 165, 166, -1, 168, -1, 170, 171, -1, - 173, 174, 175, 176, 177, 178, -1, 180, -1, 182, - 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, -1, 200, 201, 202, - 203, 204, 205, 206, -1, 208, 209, 210, 211, 212, - 213, 214, 215, 216, 217, -1, 219, -1, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, 231, -1, - -1, 234, 235, 236, 237, -1, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, - 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, - 293, 294, -1, -1, 297, 298, 299, 300, 301, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, -1, -1, -1, -1, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, - 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, - -1, 384, 385, 386, 387, 388, 389, 390, 391, 392, - -1, 394, 395, 396, 397, 398, -1, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, -1, -1, 417, 418, -1, 420, 421, 422, - 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, - 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, - 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, - 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, - 463, 464, -1, 466, 467, 468, 469, 470, 471, 472, - 473, 474, -1, -1, 477, -1, -1, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 498, 499, 500, 501, -1, - -1, -1, -1, -1, -1, 508, 509, 510, -1, -1, - -1, -1, 515, -1, 517, 518, -1, -1, -1, 522, - 523, -1, 525, 526, 3, 4, 5, 6, 7, 8, - 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, - 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, - 39, -1, -1, 42, 43, 44, -1, 46, 47, 48, - 49, 50, 51, 52, 53, 54, 55, 56, 57, -1, - 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, - 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, - 79, -1, 81, -1, 83, 84, 85, 86, 87, 88, - 89, 90, 91, 92, -1, 94, 95, 96, 97, 98, - 99, -1, 101, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, - -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, - 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, - -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, - 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, 160, 161, -1, 163, 164, 165, 166, -1, 168, - -1, 170, 171, -1, 173, 174, 175, 176, 177, 178, - -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, - 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, - -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, - 209, 210, 211, 212, 213, 214, 215, 216, 217, -1, - 219, -1, 221, 222, 223, 224, 225, 226, 227, 228, - 229, 230, 231, -1, -1, 234, 235, 236, 237, -1, - 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, - 279, 280, 281, 282, 283, 284, 285, 286, -1, 288, - 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, - 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, - 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, - 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, - 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, - 379, 380, 381, -1, -1, 384, 385, 386, 387, 388, - 389, 390, 391, 392, -1, 394, 395, 396, 397, 398, - -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 426, -1, 428, - 429, 430, -1, -1, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, - 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, - 459, 460, 461, 462, 463, 464, -1, 466, 467, 468, - 469, 470, 471, 472, 473, 474, -1, -1, 477, -1, - -1, 480, 481, 482, 483, 484, 485, 486, 487, 488, - 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, - 499, 500, 501, -1, -1, -1, -1, -1, -1, 508, - 509, 510, -1, -1, -1, -1, 515, -1, 517, -1, - -1, -1, -1, 522, 523, -1, 525, 526, 3, 4, - 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, - 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, - -1, -1, -1, -1, 39, -1, -1, 42, 43, 44, - -1, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, -1, 59, 60, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, -1, - 75, 76, 77, 78, 79, -1, 81, -1, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, -1, 94, - 95, 96, 97, 98, 99, -1, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, -1, 120, 121, 122, 123, 124, - 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, - 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, - 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, -1, 163, 164, - 165, 166, -1, 168, -1, 170, 171, -1, 173, 174, - 175, 176, 177, 178, -1, 180, -1, 182, 183, 184, - 185, -1, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, - 205, 206, -1, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, -1, 219, -1, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, -1, -1, 234, - 235, 236, 237, -1, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, - -1, -1, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - -1, -1, -1, -1, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, - 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, - 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, -1, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, - 385, 386, 387, 388, 389, 390, 391, 392, -1, 394, - 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, - -1, -1, 417, 418, -1, 420, 421, 422, 423, 424, - 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, - 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, - 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, - -1, 466, 467, 468, 469, 470, 471, 472, 473, 474, - -1, 476, 477, -1, -1, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 499, 500, 501, -1, -1, -1, - -1, -1, -1, 508, 509, 510, -1, -1, -1, -1, - 515, -1, 517, -1, -1, -1, -1, 522, 523, -1, - 525, 526, 3, 4, 5, 6, 7, 8, 9, 10, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 22, 23, 24, 25, 26, 27, 28, 29, 30, - 31, 32, 33, -1, -1, -1, -1, -1, 39, -1, - -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, - 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, - 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, - 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, - 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, - 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, - 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, 117, 118, -1, 120, - 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, - 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, - 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, - 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, - 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, - -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, - 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, - 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, - 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, - 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, - 231, -1, -1, 234, 235, 236, 237, -1, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, - -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, - 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, - 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, - 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, - 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, - 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, - -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, - 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, - 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, - 461, 462, 463, 464, -1, 466, 467, 468, 469, 470, - 471, 472, 473, 474, -1, -1, 477, -1, -1, 480, - 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, - 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, - 501, -1, -1, -1, -1, -1, -1, 508, 509, 510, - -1, -1, -1, -1, 515, -1, 517, -1, -1, -1, - -1, 522, 523, -1, 525, 526, 3, 4, 5, 6, - 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - -1, -1, 39, -1, -1, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, - 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - 237, -1, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, -1, 466, - 467, 468, 469, 470, 471, 472, 473, 474, -1, -1, - 477, -1, -1, 480, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, -1, -1, -1, -1, -1, - -1, 508, 509, 510, -1, -1, -1, -1, 515, -1, - 517, -1, -1, -1, -1, 522, 523, -1, 525, 526, - 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, - 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, - 33, -1, -1, -1, -1, -1, 39, -1, -1, 42, - 43, 44, -1, 46, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, -1, 59, 60, 61, 62, - 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, - 73, -1, 75, 76, 77, 78, 79, -1, 81, -1, - 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, - -1, 94, 95, 96, 97, 98, 99, -1, 101, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, 117, 118, -1, 120, 121, 122, - 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, - -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, - -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, -1, - 163, 164, 165, 166, -1, 168, -1, 170, 171, -1, - 173, 174, 175, 176, 177, 178, -1, 180, -1, 182, - 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, -1, 200, 201, 202, - 203, 204, 205, 206, -1, 208, 209, 210, 211, 212, - 213, 214, 215, 216, 217, -1, 219, -1, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, 231, -1, - -1, 234, 235, 236, 237, -1, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, - 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, - 293, 294, -1, -1, 297, 298, 299, 300, 301, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, -1, -1, -1, -1, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, - 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, - -1, 384, 385, 386, 387, 388, 389, 390, 391, 392, - -1, 394, 395, 396, 397, 398, -1, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, -1, -1, 417, 418, 419, 420, 421, 422, - 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, - 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, - 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, - 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, - 463, 464, -1, 466, 467, 468, 469, 470, 471, 472, - 473, 474, -1, -1, 477, -1, -1, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 498, 499, 500, 501, -1, - -1, -1, -1, -1, -1, 508, 509, 510, -1, -1, - -1, -1, 515, -1, 517, -1, -1, -1, -1, 522, - 523, -1, 525, 526, 3, 4, 5, 6, 7, 8, - 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, - 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, - 39, -1, -1, 42, 43, 44, -1, 46, 47, 48, - 49, 50, 51, 52, 53, 54, 55, 56, 57, -1, - 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, - 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, - 79, -1, 81, -1, 83, 84, 85, 86, 87, 88, - 89, 90, 91, 92, -1, 94, 95, 96, 97, 98, - 99, -1, 101, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, - -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, - 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, - -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, - 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, 160, 161, -1, 163, 164, 165, 166, -1, 168, - -1, 170, 171, -1, 173, 174, 175, 176, 177, 178, - -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, - 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, - -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, - 209, 210, 211, 212, 213, 214, 215, 216, 217, -1, - 219, -1, 221, 222, 223, 224, 225, 226, 227, 228, - 229, 230, 231, -1, -1, 234, 235, 236, 237, -1, - 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, - 279, 280, 281, 282, 283, 284, 285, 286, -1, 288, - 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, - 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, - 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, - 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, - 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, - 379, 380, 381, -1, -1, 384, 385, 386, 387, 388, - 389, 390, 391, 392, -1, 394, 395, 396, 397, 398, - -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, - -1, 420, 421, 422, 423, 424, 425, 426, -1, 428, - 429, 430, -1, -1, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, - 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, - 459, 460, 461, 462, 463, 464, -1, 466, 467, 468, - 469, 470, 471, 472, 473, 474, -1, -1, 477, -1, - -1, 480, 481, 482, 483, 484, 485, 486, 487, 488, - 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, - 499, 500, 501, -1, -1, -1, -1, -1, -1, 508, - 509, 510, -1, -1, -1, -1, 515, -1, 517, -1, - -1, -1, -1, 522, 523, -1, 525, 526, 3, 4, - 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, - 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, - -1, -1, -1, -1, 39, -1, -1, 42, 43, 44, - -1, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, -1, 59, 60, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, -1, - 75, 76, 77, 78, 79, -1, 81, -1, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, -1, 94, - 95, 96, 97, 98, 99, -1, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, -1, 120, 121, 122, 123, 124, - 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, - 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, - 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, -1, 163, 164, - 165, 166, -1, 168, -1, 170, 171, -1, 173, 174, - 175, 176, 177, 178, -1, 180, -1, 182, 183, 184, - 185, -1, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, - 205, 206, -1, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, -1, 219, -1, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, -1, -1, 234, - 235, 236, 237, -1, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, - -1, -1, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - -1, -1, -1, -1, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, - 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, - 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, -1, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, - 385, 386, 387, 388, 389, 390, 391, 392, -1, 394, - 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, - -1, -1, 417, 418, -1, 420, 421, 422, 423, 424, - 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, - 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, - 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, - -1, 466, 467, 468, 469, 470, 471, 472, 473, 474, - -1, -1, 477, -1, -1, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 499, 500, 501, -1, -1, -1, - -1, -1, -1, 508, 509, 510, -1, -1, -1, -1, - 515, -1, 517, -1, -1, -1, -1, 522, 523, -1, - 525, 526, 3, 4, 5, 6, 7, 8, 9, 10, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, - 31, 32, 33, -1, -1, -1, -1, -1, 39, -1, - -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, - 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, - 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, - 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, - 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, - 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, - 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, 117, 118, -1, 120, - 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, - 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, - 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, - 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, - 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, - -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, - 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, - 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, - 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, - 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, - 231, -1, -1, 234, 235, 236, 237, -1, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, - -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, - 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, - 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, - 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, - 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, - 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, - -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, - 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, - 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, - 461, 462, 463, 464, -1, 466, 467, 468, 469, 470, - 471, 472, 473, 474, -1, -1, 477, -1, -1, 480, - 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, - 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, - 501, -1, -1, -1, -1, -1, -1, 508, 509, 510, - -1, -1, -1, -1, 515, -1, 517, -1, -1, -1, - -1, 522, 523, -1, 525, 526, 3, 4, 5, 6, - 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - -1, -1, 39, -1, -1, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, - 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - 237, -1, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, -1, 466, - 467, 468, 469, 470, 471, 472, 473, 474, -1, -1, - 477, -1, -1, 480, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, -1, -1, -1, -1, -1, - -1, 508, 509, 510, -1, -1, -1, -1, 515, -1, - 517, -1, -1, -1, -1, 522, 523, -1, 525, 526, - 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, - 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, - 33, -1, -1, -1, -1, -1, 39, -1, -1, 42, - 43, 44, -1, 46, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, -1, 59, 60, 61, 62, - 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, - 73, -1, 75, 76, 77, 78, 79, -1, 81, -1, - 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, - -1, 94, 95, 96, 97, 98, 99, -1, 101, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, 117, 118, -1, 120, 121, 122, - 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, - -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, - -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, -1, - 163, 164, 165, 166, -1, 168, -1, 170, 171, -1, - 173, 174, 175, 176, 177, 178, -1, 180, -1, 182, - 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, -1, 200, 201, 202, - 203, 204, 205, 206, -1, 208, 209, 210, 211, 212, - 213, 214, 215, 216, 217, -1, 219, -1, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, 231, -1, - -1, 234, 235, 236, 237, -1, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, - 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, - 293, 294, -1, -1, 297, 298, 299, 300, 301, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, -1, -1, -1, -1, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, - 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, - -1, 384, 385, 386, 387, 388, 389, 390, 391, 392, - -1, 394, 395, 396, 397, 398, -1, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, -1, -1, 417, 418, -1, 420, 421, 422, - 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, - 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, - 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, - 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, - 463, 464, -1, 466, 467, 468, 469, 470, 471, 472, - 473, 474, -1, -1, 477, -1, -1, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 498, 499, 500, 501, -1, - -1, -1, -1, -1, -1, 508, 509, 510, -1, -1, - -1, -1, 515, -1, 517, -1, -1, -1, -1, 522, - 523, -1, 525, 526, 3, 4, 5, 6, 7, 8, - 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, - 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, - 39, -1, -1, 42, 43, 44, -1, 46, 47, 48, - 49, 50, 51, 52, 53, 54, 55, 56, 57, -1, - 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, - 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, - 79, -1, 81, -1, 83, 84, 85, 86, 87, 88, - 89, 90, 91, 92, -1, 94, 95, 96, 97, 98, - 99, -1, 101, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, - -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, - 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, - -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, - 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, 160, 161, -1, 163, 164, 165, 166, -1, 168, - -1, 170, 171, -1, 173, 174, 175, 176, 177, 178, - -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, - 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, - -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, - 209, 210, 211, 212, 213, 214, 215, 216, 217, -1, - 219, -1, 221, 222, 223, 224, 225, 226, 227, 228, - 229, 230, 231, -1, -1, 234, 235, 236, 237, -1, - 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, - 279, 280, 281, 282, 283, 284, 285, 286, -1, 288, - 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, - 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, - 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, - 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, - 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, - 379, 380, 381, -1, -1, 384, 385, 386, 387, 388, - 389, 390, 391, 392, -1, 394, 395, 396, 397, 398, - -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, - -1, 420, 421, 422, 423, 424, 425, 426, -1, 428, - 429, 430, -1, -1, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, - 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, - 459, 460, 461, 462, 463, 464, -1, 466, 467, 468, - 469, 470, 471, 472, 473, 474, -1, -1, 477, -1, - -1, 480, 481, 482, 483, 484, 485, 486, 487, 488, - 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, - 499, 500, 501, -1, -1, -1, -1, -1, -1, 508, - 509, 510, -1, -1, -1, -1, 515, -1, 517, -1, - -1, -1, -1, 522, 523, -1, 525, 526, 3, 4, - 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, - 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, - -1, -1, -1, -1, 39, -1, -1, 42, 43, 44, - -1, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, -1, 59, 60, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, -1, - 75, 76, 77, 78, 79, -1, 81, -1, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, -1, 94, - 95, 96, 97, 98, 99, -1, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, -1, 120, 121, 122, 123, 124, - 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, - 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, - 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, -1, 163, 164, - 165, 166, -1, 168, -1, 170, 171, -1, 173, 174, - 175, 176, 177, 178, -1, 180, -1, 182, 183, 184, - 185, -1, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, - 205, 206, -1, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, -1, 219, -1, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, -1, -1, 234, - 235, 236, 237, -1, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, - -1, -1, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - -1, -1, -1, -1, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, - 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, - 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, -1, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, - 385, 386, 387, 388, 389, 390, 391, 392, -1, 394, - 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, - -1, -1, 417, 418, -1, 420, 421, 422, 423, 424, - 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, - 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, - 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, - -1, 466, 467, 468, 469, 470, 471, 472, 473, 474, - -1, -1, 477, -1, -1, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 499, 500, 501, -1, -1, -1, - -1, -1, -1, 508, 509, 510, -1, -1, -1, -1, - 515, -1, 517, -1, -1, -1, -1, 522, 523, -1, - 525, 526, 3, 4, 5, 6, 7, 8, 9, 10, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, - 31, 32, 33, -1, -1, -1, -1, -1, 39, -1, - -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, - 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, - 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, - 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, - 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, - 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, - 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, 117, 118, -1, 120, - 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, - 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, - 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, - 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, - 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, - -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, - 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, - 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, - 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, - 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, - 231, -1, -1, 234, 235, 236, 237, -1, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, - -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, - 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, - 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, - 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, - 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, - 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, - -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, - 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, - 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, - 461, 462, 463, 464, -1, 466, 467, 468, 469, 470, - 471, 472, 473, 474, -1, -1, 477, -1, -1, 480, - 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, - 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, - 501, -1, -1, -1, -1, -1, -1, 508, 509, 510, - -1, -1, -1, -1, 515, -1, 517, -1, -1, -1, - -1, 522, 523, -1, 525, 526, 3, 4, 5, 6, - 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - -1, -1, 39, -1, -1, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, - 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - 237, -1, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, -1, 466, - 467, 468, 469, 470, 471, 472, 473, 474, -1, -1, - 477, -1, -1, 480, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, -1, -1, -1, -1, -1, - -1, 508, 509, 510, -1, -1, -1, -1, 515, -1, - 517, -1, -1, -1, -1, 522, 523, -1, 525, 526, - 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, - 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, - 33, -1, -1, -1, -1, -1, 39, -1, -1, 42, - 43, 44, -1, 46, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, -1, 59, 60, 61, 62, - 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, - 73, -1, 75, 76, 77, 78, 79, -1, 81, -1, - 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, - -1, 94, 95, 96, 97, 98, 99, -1, 101, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, - 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, - -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, - -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, -1, - 163, 164, 165, 166, -1, 168, -1, 170, 171, -1, - 173, 174, 175, 176, 177, 178, -1, 180, -1, 182, - 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, -1, 200, 201, 202, - 203, 204, 205, 206, -1, 208, 209, 210, 211, 212, - 213, 214, 215, 216, 217, -1, 219, -1, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, 231, -1, - -1, 234, 235, 236, 237, -1, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, -1, 276, 277, 278, 279, 280, 281, 282, - 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, - 293, 294, -1, -1, 297, 298, 299, 300, 301, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, -1, -1, -1, -1, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, - 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, - -1, 384, 385, 386, 387, 388, 389, 390, 391, 392, - -1, 394, 395, 396, 397, 398, -1, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, -1, -1, 417, 418, -1, 420, 421, 422, - 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, - 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, - 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, - 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, - 463, 464, -1, 466, 467, 468, 469, 470, 471, 472, - 473, 474, -1, -1, 477, -1, -1, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 498, 499, 500, -1, -1, - -1, -1, -1, -1, -1, 508, 509, -1, -1, -1, - -1, -1, 515, -1, 517, -1, -1, -1, -1, 522, - 523, -1, 525, 526, 3, 4, 5, 6, 7, 8, - 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, - 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, - 39, -1, -1, 42, 43, 44, -1, 46, 47, 48, - 49, 50, 51, 52, 53, 54, 55, 56, 57, -1, - 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, - 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, - 79, -1, 81, -1, 83, 84, 85, 86, 87, 88, - 89, 90, 91, 92, -1, 94, 95, 96, 97, 98, - 99, -1, 101, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, - -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, - 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, - -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, - 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, 160, 161, -1, 163, 164, 165, 166, -1, 168, - -1, 170, 171, -1, 173, 174, 175, 176, 177, 178, - -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, - 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, - -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, - 209, 210, 211, 212, 213, 214, 215, 216, 217, -1, - 219, -1, 221, -1, -1, 224, 225, 226, 227, 228, - 229, 230, 231, -1, -1, 234, 235, 236, 237, -1, - 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, 274, -1, 276, 277, -1, - 279, 280, 281, 282, 283, 284, 285, 286, -1, 288, - 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, - 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, - 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, - 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, - 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, - 379, 380, 381, -1, -1, 384, 385, 386, 387, 388, - 389, 390, 391, 392, -1, 394, 395, 396, 397, 398, - -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, - -1, 420, 421, 422, 423, 424, 425, 426, -1, 428, - 429, 430, -1, -1, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, - 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, - 459, 460, 461, 462, 463, 464, -1, 466, 467, 468, - 469, 470, 471, 472, 473, 474, -1, -1, 477, -1, - -1, 480, 481, 482, 483, 484, 485, 486, 487, 488, - 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, - 499, 500, 501, -1, -1, -1, -1, -1, -1, 508, - 509, 510, -1, -1, -1, -1, 515, -1, 517, -1, - -1, -1, -1, 522, 523, -1, 525, 526, 3, 4, - 5, 6, 7, -1, 9, 10, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, - 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, - -1, -1, -1, -1, 39, -1, -1, 42, 43, 44, - -1, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, -1, 59, 60, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, -1, - 75, 76, 77, 78, 79, -1, 81, -1, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, -1, 94, - 95, 96, 97, 98, 99, -1, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, - 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, - 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, - 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, -1, 163, 164, - 165, 166, -1, 168, -1, 170, 171, -1, 173, 174, - 175, 176, 177, 178, -1, 180, -1, 182, 183, 184, - 185, -1, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, - 205, 206, -1, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, -1, 219, -1, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, -1, -1, 234, - 235, 236, 237, -1, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - -1, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, - -1, -1, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - -1, -1, -1, -1, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, - 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, - 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, -1, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, - 385, 386, 387, 388, 389, 390, 391, 392, -1, 394, - 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, - -1, -1, 417, 418, -1, 420, 421, 422, 423, 424, - 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, - 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, - 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, - -1, 466, 467, 468, 469, 470, 471, 472, 473, 474, - -1, -1, 477, -1, -1, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 499, 500, -1, -1, -1, -1, - -1, -1, -1, 508, 509, -1, -1, -1, -1, -1, - 515, -1, 517, -1, -1, -1, -1, 522, 523, -1, - 525, 526, 3, 4, 5, 6, 7, 8, 9, 10, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, - 31, 32, 33, -1, -1, -1, -1, -1, 39, -1, - -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, - 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, - 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, - 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, - 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, - 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, - 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, - 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, - 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, - 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, - 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, - 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, - -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, - 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, - 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, - 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, - 221, -1, 223, 224, 225, 226, 227, 228, 229, 230, - 231, -1, -1, 234, 235, 236, 237, -1, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, 274, -1, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, - -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, - 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, - 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, - 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, - 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, - 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, - -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, - 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, - 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, - 461, 462, 463, 464, -1, 466, 467, 468, 469, 470, - 471, 472, 473, 474, -1, -1, 477, -1, -1, 480, - 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, - 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, - -1, -1, -1, -1, -1, -1, -1, 508, 509, -1, - -1, -1, -1, -1, 515, -1, 517, -1, -1, -1, - -1, 522, 523, -1, 525, 526, 3, 4, 5, 6, - 7, -1, 9, 10, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - -1, -1, 39, -1, -1, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, - 177, 178, -1, 180, 181, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - 237, -1, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, -1, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, + 118, 119, 120, 121, 122, 123, 124, 125, 825, 126, + 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, + 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, + 147, 148, 149, 0, 0, 150, 151, 152, 153, 154, + 155, 156, 0, 157, 158, 159, 160, 161, 0, 0, + 0, 163, 164, 165, 166, 167, 168, 0, 170, 171, + 172, 0, 173, 174, 175, 176, 177, 178, 0, 0, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, + 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, + 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, + 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 0, 229, + 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, + 0, 0, 238, 239, 528, 0, 826, 0, 243, 0, + 244, 245, 246, 247, 0, 248, 249, 250, 251, 252, + 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, + 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, + 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, + 0, 0, 281, 0, 283, 284, 285, 286, 287, 288, + 0, 0, 289, 0, 291, 0, 0, 293, 294, 827, + 296, 297, 298, 299, 300, 529, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 0, 324, 325, + 326, 327, 328, 0, 329, 330, 0, 332, 0, 333, + 334, 335, 336, 337, 338, 0, 339, 340, 0, 0, + 341, 342, 343, 0, 0, 344, 345, 346, 0, 348, + 0, 350, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 360, 361, 0, 0, 0, 0, 362, 363, 364, + 0, 366, 367, 368, 369, 370, 371, 0, 372, 373, + 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, + 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, + 401, 402, 0, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, + 0, 0, 421, 422, 423, 424, 828, 426, 427, 428, + 429, 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, -1, 466, - 467, 468, 469, 470, 471, 472, 473, 474, -1, -1, - 477, -1, -1, 480, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 515, -1, - 517, -1, -1, -1, -1, 522, 523, -1, 525, 526, - 3, 4, 5, 6, 7, -1, 9, 10, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, - 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, - 33, -1, -1, -1, -1, -1, 39, -1, -1, 42, - 43, 44, -1, 46, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, -1, 59, 60, 61, 62, - 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, - 73, -1, 75, 76, 77, 78, 79, -1, 81, -1, - 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, - -1, 94, 95, 96, 97, 98, 99, -1, 101, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, - 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, - -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, - -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, -1, - 163, 164, 165, 166, -1, 168, -1, 170, 171, -1, - 173, 174, 175, 176, 177, 178, -1, 180, -1, 182, - 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, -1, 200, 201, 202, - 203, 204, 205, 206, -1, 208, 209, 210, 211, 212, - 213, 214, 215, 216, 217, -1, 219, -1, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, 231, -1, - -1, 234, 235, 236, 237, -1, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, -1, 276, 277, 278, 279, 280, 281, 282, - 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, - 293, 294, -1, -1, 297, 298, 299, 300, 301, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, -1, -1, -1, -1, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, - 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, - -1, 384, 385, 386, 387, 388, 389, 390, 391, 392, - -1, 394, 395, 396, 397, 398, -1, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, -1, -1, 417, 418, -1, 420, 421, 422, - 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, - 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, - 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, - 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, - 463, 464, -1, 466, 467, 468, 469, 470, 471, 472, - 473, 474, -1, -1, 477, -1, -1, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 498, 499, 500, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 515, -1, 517, -1, -1, -1, -1, 522, - 523, -1, 525, 526, 3, 4, 5, 6, 7, -1, - 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, - 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, - 39, -1, -1, 42, 43, 44, -1, 46, 47, 48, - 49, 50, 51, 52, 53, 54, 55, 56, 57, -1, - 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, - 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, - 79, -1, 81, -1, 83, 84, 85, 86, 87, 88, - 89, 90, 91, 92, -1, 94, 95, 96, 97, 98, - 99, -1, 101, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, - -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, - 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, - -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, - 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, 160, 161, -1, 163, 164, 165, 166, -1, 168, - -1, 170, 171, -1, 173, 174, 175, 176, 177, 178, - -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, - 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, - -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, - 209, 210, 211, 212, 213, 214, 215, 216, 217, -1, - 219, -1, 221, 222, 223, 224, 225, 226, 227, 228, - 229, 230, 231, -1, -1, 234, 235, 236, 237, -1, - 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, 274, -1, 276, 277, 278, - 279, 280, 281, 282, 283, 284, 285, 286, -1, 288, - 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, - 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, - 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, - 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, - 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, - 379, 380, 381, -1, -1, 384, 385, 386, 387, 388, - 389, 390, 391, 392, -1, 394, 395, 396, 397, 398, - -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, - -1, 420, 421, 422, 423, 424, 425, 426, -1, 428, - 429, 430, -1, -1, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, - 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, - 459, 460, 461, 462, 463, 464, -1, 466, 467, 468, - 469, 470, 471, 472, 473, 474, -1, -1, 477, -1, - -1, 480, 481, 482, 483, 484, 485, 486, 487, 488, - 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, - 499, 500, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 515, -1, 517, -1, - -1, -1, -1, 522, 523, -1, 525, 526, 3, 4, - 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, - 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, - -1, -1, -1, -1, 39, -1, -1, 42, 43, 44, - -1, 46, 47, 48, 49, 50, 51, 52, -1, 54, - 55, 56, 57, -1, 59, 60, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, -1, - 75, 76, 77, 78, 79, -1, 81, -1, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, -1, 94, - 95, 96, 97, 98, 99, -1, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, -1, 120, 121, 122, 123, 124, - 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, - 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, - -1, 146, -1, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, -1, 163, 164, - 165, 166, -1, 168, -1, 170, 171, -1, 173, 174, - 175, 176, -1, 178, -1, 180, -1, 182, 183, 184, - 185, -1, 187, 188, 189, 190, 191, 192, 193, -1, - 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, - 205, 206, -1, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, -1, 219, -1, 221, -1, -1, 224, - 225, 226, 227, 228, 229, 230, 231, -1, -1, 234, - 235, 236, -1, -1, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - -1, 276, 277, -1, 279, 280, 281, 282, 283, 284, - 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, - -1, -1, 297, 298, 299, 300, 301, 302, 303, 304, + 530, 448, 449, 0, 0, 450, 451, 0, 452, 0, + 454, 455, 456, 457, 458, 0, 459, 829, 461, 0, + 0, 830, 463, 464, 465, 466, 0, 467, 468, 469, + 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, + 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, + 486, 487, 488, 0, 489, 0, 491, 492, 493, 494, + 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, + 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, + 511, 512, 513, 514, 515, 516, 517, 518, 519, 527, + 0, 553, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, + 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, + 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, + 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, + 149, 0, 0, 150, 151, 152, 153, 154, 155, 156, + 0, 157, 158, 159, 160, 161, 0, 0, 0, 163, + 164, 165, 166, 167, 168, 0, 170, 171, 172, 0, + 173, 174, 175, 176, 177, 178, 0, 0, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, + 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, + 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, + 214, 215, 216, 0, 217, 218, 219, 220, 221, 222, + 223, 224, 225, 226, 227, 228, 0, 229, 0, 230, + 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, + 238, 239, 528, 0, 242, 0, 243, 0, 244, 245, + 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, + 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, + 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, + 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, + 281, 0, 283, 284, 285, 286, 287, 288, 0, 0, + 289, 0, 291, 0, 0, 293, 294, 295, 296, 297, + 298, 299, 300, 529, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 0, 324, 325, 326, 327, + 328, 0, 329, 330, 0, 332, 0, 333, 334, 335, + 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, + 343, 0, 0, 344, 345, 346, 0, 348, 0, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + 361, 0, 0, 0, 0, 362, 363, 364, 0, 366, + 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, + 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, + 385, 862, 387, 0, 388, 389, 390, 391, 392, 393, + 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, + 0, 404, 405, 406, 407, 408, 409, 410, 411, 412, + 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, + 421, 422, 423, 424, 425, 426, 427, 428, 429, 0, + 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, + 439, 440, 441, 442, 443, 444, 445, 446, 530, 448, + 449, 0, 0, 450, 451, 0, 452, 0, 454, 455, + 456, 457, 458, 0, 459, 460, 461, 0, 0, 462, + 463, 464, 465, 466, 0, 467, 468, 469, 470, 471, + 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, + 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, + 488, 0, 489, 0, 491, 492, 493, 494, 495, 496, + 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, + 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, + 513, 514, 515, 516, 517, 518, 519, 527, 0, 553, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, + 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, + 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, + 0, 150, 151, 152, 153, 154, 155, 156, 0, 157, + 158, 159, 160, 161, 0, 0, 0, 163, 164, 165, + 166, 167, 168, 0, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 0, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, + 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, + 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, + 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, + 528, 0, 242, 0, 243, 0, 244, 245, 246, 247, + 0, 248, 249, 250, 251, 252, 895, 254, 0, 256, + 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, + 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, + 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 0, + 291, 0, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 529, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 322, 0, 324, 325, 326, 327, 328, 0, + 329, 330, 0, 332, 0, 333, 334, 335, 336, 337, + 338, 0, 339, 340, 0, 0, 341, 342, 343, 0, + 0, 344, 345, 346, 0, 348, 0, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, + 0, 0, 0, 362, 363, 364, 0, 366, 367, 368, + 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, + 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, + 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 0, 401, 402, 0, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 0, 0, 431, + 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 530, 448, 449, 0, + 0, 450, 451, 0, 452, 0, 454, 455, 456, 457, + 458, 0, 459, 460, 461, 0, 0, 462, 463, 464, + 465, 466, 0, 467, 468, 469, 470, 471, 472, 473, + 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 487, 488, 0, + 489, 0, 491, 492, 493, 494, 495, 496, 497, 0, + 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 527, 0, 553, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, + 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, + 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, + 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, + 151, 152, 153, 154, 155, 156, 0, 157, 158, 159, + 160, 161, 0, 0, 0, 163, 164, 165, 166, 167, + 168, 0, 170, 171, 172, 0, 173, 174, 175, 176, + 177, 178, 0, 0, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 0, + 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, + 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, + 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, + 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, + 234, 0, 235, 0, 0, 0, 238, 239, 528, 0, + 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, + 249, 250, 251, 252, 898, 254, 0, 256, 257, 258, + 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, + 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, + 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, + 285, 286, 287, 288, 0, 0, 289, 0, 291, 0, + 0, 293, 294, 295, 296, 297, 298, 299, 300, 529, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 0, 324, 325, 326, 327, 328, 0, 329, 330, + 0, 332, 0, 333, 334, 335, 336, 337, 338, 0, + 339, 340, 0, 0, 341, 342, 343, 0, 0, 344, + 345, 346, 0, 348, 0, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, + 0, 362, 363, 364, 0, 366, 367, 368, 369, 370, + 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, + 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, + 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, + 398, 399, 400, 0, 401, 402, 0, 404, 405, 406, + 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, + 425, 426, 427, 428, 429, 0, 0, 431, 432, 433, + 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, + 443, 444, 445, 446, 530, 448, 449, 0, 0, 450, + 451, 0, 452, 0, 454, 455, 456, 457, 458, 0, + 459, 460, 461, 0, 0, 462, 463, 464, 465, 466, + 0, 467, 468, 469, 470, 471, 472, 473, 474, 0, + 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, + 482, 483, 484, 485, 486, 487, 488, 0, 489, 0, + 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, + 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, + 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, + 517, 518, 519, 527, 0, 553, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, + 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, + 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, + 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, + 153, 154, 155, 156, 0, 157, 158, 159, 160, 161, + 0, 0, 0, 163, 164, 165, 166, 167, 168, 0, + 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, + 0, 0, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, + 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, + 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, + 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, + 235, 0, 0, 0, 238, 239, 528, 0, 242, 0, + 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, + 251, 252, 902, 254, 0, 256, 257, 258, 259, 0, + 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, + 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, + 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, + 287, 288, 0, 0, 289, 0, 291, 0, 0, 293, + 294, 295, 296, 297, 298, 299, 300, 529, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 322, 0, + 324, 325, 326, 327, 328, 0, 329, 330, 0, 332, + 0, 333, 334, 335, 336, 337, 338, 0, 339, 340, + 0, 0, 341, 342, 343, 0, 0, 344, 345, 346, + 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, + 363, 364, 0, 366, 367, 368, 369, 370, 371, 0, + 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, + 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, + 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, + 400, 0, 401, 402, 0, 404, 405, 406, 407, 408, + 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, + 419, 420, 0, 0, 421, 422, 423, 424, 425, 426, + 427, 428, 429, 0, 0, 431, 432, 433, 434, 0, + 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, + 445, 446, 530, 448, 449, 0, 0, 450, 451, 0, + 452, 0, 454, 455, 456, 457, 458, 0, 459, 460, + 461, 0, 0, 462, 463, 464, 465, 466, 0, 467, + 468, 469, 470, 471, 472, 473, 474, 0, 0, 475, + 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, + 484, 485, 486, 487, 488, 0, 489, 0, 491, 492, + 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, + 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, + 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, + 519, 527, 0, 553, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, + 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, + 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, + 147, 148, 149, 0, 0, 150, 151, 152, 153, 154, + 155, 156, 0, 157, 158, 159, 160, 161, 0, 0, + 0, 163, 164, 165, 166, 167, 168, 0, 170, 171, + 172, 0, 173, 174, 175, 176, 177, 178, 0, 0, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, + 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, + 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, + 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 0, 229, + 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, + 0, 0, 238, 239, 528, 0, 242, 0, 243, 0, + 244, 245, 246, 247, 0, 248, 249, 250, 251, 252, + 932, 254, 0, 256, 257, 258, 259, 0, 260, 261, + 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, + 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, + 0, 0, 281, 0, 283, 284, 285, 286, 287, 288, + 0, 0, 289, 0, 291, 0, 0, 293, 294, 295, + 296, 297, 298, 299, 300, 529, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 0, 324, 325, + 326, 327, 328, 0, 329, 330, 0, 332, 0, 333, + 334, 335, 336, 337, 338, 0, 339, 340, 0, 0, + 341, 342, 343, 0, 0, 344, 345, 346, 0, 348, + 0, 350, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 360, 361, 0, 0, 0, 0, 362, 363, 364, + 0, 366, 367, 368, 369, 370, 371, 0, 372, 373, + 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, + 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, + 401, 402, 0, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, + 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, + 429, 0, 0, 431, 432, 433, 434, 0, 435, 436, + 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, + 530, 448, 449, 0, 0, 450, 451, 0, 452, 0, + 454, 455, 456, 457, 458, 0, 459, 460, 461, 0, + 0, 462, 463, 464, 465, 466, 0, 467, 468, 469, + 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, + 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, + 486, 487, 488, 0, 489, 0, 491, 492, 493, 494, + 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, + 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, + 511, 512, 513, 514, 515, 516, 517, 518, 519, 527, + 0, 553, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, + 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, + 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, + 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, + 149, 0, 0, 150, 151, 152, 153, 154, 155, 156, + 0, 157, 158, 159, 160, 161, 0, 0, 0, 163, + 164, 165, 166, 167, 168, 0, 170, 171, 172, 0, + 173, 174, 175, 176, 177, 178, 0, 0, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, + 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, + 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, + 214, 215, 216, 0, 217, 218, 219, 220, 221, 222, + 223, 224, 225, 226, 227, 228, 0, 229, 0, 230, + 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, + 238, 239, 528, 0, 242, 0, 243, 0, 244, 245, + 246, 247, 0, 248, 249, 250, 251, 252, 960, 254, + 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, + 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, + 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, + 281, 0, 283, 284, 285, 286, 287, 288, 0, 0, + 289, 0, 291, 0, 0, 293, 294, 295, 296, 297, + 298, 299, 300, 529, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 0, 324, 325, 326, 327, + 328, 0, 329, 330, 0, 332, 0, 333, 334, 335, + 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, + 343, 0, 0, 344, 345, 346, 0, 348, 0, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + 361, 0, 0, 0, 0, 362, 363, 364, 0, 366, + 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, + 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, + 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, + 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, + 0, 404, 405, 406, 407, 408, 409, 410, 411, 412, + 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, + 421, 422, 423, 424, 425, 426, 427, 428, 429, 0, + 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, + 439, 440, 441, 442, 443, 444, 445, 446, 530, 448, + 449, 0, 0, 450, 451, 0, 452, 0, 454, 455, + 456, 457, 458, 0, 459, 460, 461, 0, 0, 462, + 463, 464, 465, 466, 0, 467, 468, 469, 470, 471, + 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, + 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, + 488, 0, 489, 0, 491, 492, 493, 494, 495, 496, + 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, + 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, + 513, 514, 515, 516, 517, 518, 519, 527, 0, 553, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, + 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, + 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, + 0, 150, 151, 152, 153, 154, 155, 156, 0, 157, + 158, 159, 160, 161, 0, 0, 0, 163, 164, 165, + 166, 167, 168, 0, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 0, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, + 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, + 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, + 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, + 528, 0, 242, 0, 243, 0, 244, 245, 246, 247, + 0, 248, 249, 250, 251, 252, 963, 254, 0, 256, + 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, + 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, + 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 0, + 291, 0, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 529, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 322, 0, 324, 325, 326, 327, 328, 0, + 329, 330, 0, 332, 0, 333, 334, 335, 336, 337, + 338, 0, 339, 340, 0, 0, 341, 342, 343, 0, + 0, 344, 345, 346, 0, 348, 0, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, + 0, 0, 0, 362, 363, 364, 0, 366, 367, 368, + 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, + 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, + 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 0, 401, 402, 0, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 0, 0, 431, + 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 530, 448, 449, 0, + 0, 450, 451, 0, 452, 0, 454, 455, 456, 457, + 458, 0, 459, 460, 461, 0, 0, 462, 463, 464, + 465, 466, 0, 467, 468, 469, 470, 471, 472, 473, + 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 487, 488, 0, + 489, 0, 491, 492, 493, 494, 495, 496, 497, 0, + 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 527, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, + 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, + 0, 0, 1005, 0, 0, 130, 131, 0, 132, 133, + 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, + 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, + 151, 152, 153, 154, 155, 156, 0, 157, 158, 159, + 160, 161, 0, 0, 0, 163, 164, 165, 166, 167, + 168, 0, 170, 171, 172, 0, 173, 174, 175, 176, + 177, 178, 0, 0, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 0, + 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, + 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, + 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, + 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, + 234, 0, 235, 0, 0, 0, 238, 239, 528, 0, + 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, + 249, 250, 251, 252, 253, 254, 0, 256, 257, 258, + 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, + 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, + 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, + 285, 286, 287, 288, 0, 0, 289, 0, 291, 0, + 0, 293, 294, 295, 296, 297, 298, 299, 300, 529, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 0, 324, 325, 326, 327, 328, 0, 329, 330, + 0, 332, 0, 333, 334, 335, 336, 337, 338, 0, + 339, 340, 0, 0, 341, 342, 343, 0, 0, 344, + 345, 346, 0, 348, 0, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, + 0, 362, 363, 364, 0, 366, 367, 368, 369, 370, + 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, + 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, + 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, + 398, 399, 400, 0, 401, 402, 0, 404, 405, 406, + 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, + 425, 426, 427, 428, 429, 0, 0, 431, 432, 433, + 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, + 443, 444, 445, 446, 530, 448, 449, 0, 0, 450, + 451, 0, 452, 0, 454, 455, 456, 457, 458, 0, + 459, 460, 461, 0, 0, 462, 463, 464, 465, 466, + 0, 467, 468, 469, 470, 471, 472, 473, 474, 0, + 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, + 482, 483, 484, 485, 486, 487, 488, 0, 489, 0, + 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, + 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, + 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, + 517, 518, 519, 527, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, + 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, + 1028, 0, 0, 130, 131, 0, 132, 133, 134, 0, + 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, + 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, + 153, 154, 155, 156, 0, 157, 158, 159, 160, 161, + 0, 0, 0, 163, 164, 165, 166, 167, 168, 0, + 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, + 0, 0, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, + 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, + 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, + 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, + 235, 0, 0, 0, 238, 239, 528, 0, 242, 0, + 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, + 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, + 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, + 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, + 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, + 287, 288, 0, 0, 289, 0, 291, 0, 0, 293, + 294, 295, 296, 297, 298, 299, 300, 529, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 322, 0, + 324, 325, 326, 327, 328, 0, 329, 330, 0, 332, + 0, 333, 334, 335, 336, 337, 338, 0, 339, 340, + 0, 0, 341, 342, 343, 0, 0, 344, 345, 346, + 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, + 363, 364, 0, 366, 367, 368, 369, 370, 371, 0, + 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, + 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, + 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, + 400, 0, 401, 402, 0, 404, 405, 406, 407, 408, + 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, + 419, 420, 0, 0, 421, 422, 423, 424, 425, 426, + 427, 428, 429, 0, 0, 431, 432, 433, 434, 0, + 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, + 445, 446, 530, 448, 449, 0, 0, 450, 451, 0, + 452, 0, 454, 455, 456, 457, 458, 0, 459, 460, + 461, 0, 0, 462, 463, 464, 465, 466, 0, 467, + 468, 469, 470, 471, 472, 473, 474, 0, 0, 475, + 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, + 484, 485, 486, 487, 488, 0, 489, 0, 491, 492, + 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, + 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, + 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, + 519, 527, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 118, 119, 120, 121, 122, 123, 124, 125, 825, 126, + 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, + 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, + 147, 148, 149, 0, 0, 150, 151, 152, 153, 154, + 155, 156, 0, 157, 158, 159, 160, 161, 0, 0, + 0, 163, 164, 165, 166, 167, 168, 0, 170, 171, + 172, 0, 173, 174, 175, 176, 177, 178, 0, 0, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, + 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, + 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, + 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 0, 229, + 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, + 0, 0, 238, 239, 528, 0, 242, 0, 243, 0, + 244, 245, 246, 247, 0, 248, 249, 250, 251, 252, + 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, + 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, + 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, + 0, 0, 281, 0, 283, 284, 285, 286, 287, 288, + 0, 0, 289, 0, 291, 0, 0, 293, 294, 295, + 296, 297, 298, 299, 300, 529, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 0, 324, 325, + 326, 327, 328, 0, 329, 330, 0, 332, 0, 333, + 334, 335, 336, 337, 338, 0, 339, 340, 0, 0, + 341, 342, 343, 0, 0, 344, 345, 346, 0, 348, + 0, 350, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 360, 361, 0, 0, 0, 0, 362, 363, 364, + 0, 366, 367, 368, 369, 370, 371, 0, 372, 373, + 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, + 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, + 401, 402, 0, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, + 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, + 429, 0, 0, 431, 432, 433, 434, 0, 435, 436, + 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, + 530, 448, 449, 0, 0, 450, 451, 0, 452, 0, + 454, 455, 456, 457, 458, 0, 459, 829, 461, 0, + 0, 830, 463, 464, 465, 466, 0, 467, 468, 469, + 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, + 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, + 486, 487, 488, 0, 489, 0, 491, 492, 493, 494, + 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, + 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, + 511, 512, 513, 514, 515, 516, 517, 518, 519, 527, + 0, 553, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, + 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, + 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, + 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, + 149, 0, 0, 150, 151, 152, 153, 154, 155, 156, + 0, 157, 158, 159, 160, 161, 0, 0, 0, 163, + 164, 165, 166, 167, 168, 0, 170, 171, 172, 0, + 173, 174, 175, 176, 177, 178, 0, 0, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, + 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, + 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, + 214, 215, 216, 0, 217, 218, 219, 220, 221, 222, + 223, 224, 225, 226, 227, 228, 0, 229, 0, 230, + 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, + 238, 239, 528, 0, 242, 0, 243, 0, 244, 245, + 246, 247, 0, 248, 249, 250, 251, 252, 1312, 254, + 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, + 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, + 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, + 281, 0, 283, 284, 285, 286, 287, 288, 0, 0, + 289, 0, 291, 0, 0, 293, 294, 295, 296, 297, + 298, 299, 300, 529, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 0, 324, 325, 326, 327, + 328, 0, 329, 330, 0, 332, 0, 333, 334, 335, + 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, + 343, 0, 0, 344, 345, 346, 0, 348, 0, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + 361, 0, 0, 0, 0, 362, 363, 364, 0, 366, + 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, + 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, + 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, + 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, + 0, 404, 405, 406, 407, 408, 409, 410, 411, 412, + 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, + 421, 422, 423, 424, 425, 426, 427, 428, 429, 0, + 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, + 439, 440, 441, 442, 443, 444, 445, 446, 530, 448, + 449, 0, 0, 450, 451, 0, 452, 0, 454, 455, + 456, 457, 458, 0, 459, 460, 461, 0, 0, 462, + 463, 464, 465, 466, 0, 467, 468, 469, 470, 471, + 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, + 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, + 488, 0, 489, 0, 491, 492, 493, 494, 495, 496, + 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, + 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, + 513, 514, 515, 516, 517, 518, 519, 527, 0, 553, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, + 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, + 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, + 0, 150, 151, 152, 153, 154, 155, 156, 0, 157, + 158, 159, 160, 161, 0, 0, 0, 163, 164, 165, + 166, 167, 168, 0, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 0, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, + 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, + 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, + 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, + 528, 0, 242, 0, 243, 0, 244, 245, 246, 247, + 0, 248, 249, 250, 251, 252, 1314, 254, 0, 256, + 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, + 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, + 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 0, + 291, 0, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 529, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 322, 0, 324, 325, 326, 327, 328, 0, + 329, 330, 0, 332, 0, 333, 334, 335, 336, 337, + 338, 0, 339, 340, 0, 0, 341, 342, 343, 0, + 0, 344, 345, 346, 0, 348, 0, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, + 0, 0, 0, 362, 363, 364, 0, 366, 367, 368, + 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, + 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, + 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 0, 401, 402, 0, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 0, 0, 431, + 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 530, 448, 449, 0, + 0, 450, 451, 0, 452, 0, 454, 455, 456, 457, + 458, 0, 459, 460, 461, 0, 0, 462, 463, 464, + 465, 466, 0, 467, 468, 469, 470, 471, 472, 473, + 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 487, 488, 0, + 489, 0, 491, 492, 493, 494, 495, 496, 497, 0, + 0, 498, 0, 0, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 527, 0, 553, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, + 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, + 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, + 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, + 151, 152, 153, 154, 155, 156, 0, 157, 158, 159, + 160, 161, 0, 0, 0, 163, 164, 165, 166, 167, + 168, 0, 170, 171, 172, 0, 173, 174, 175, 176, + 177, 178, 0, 0, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 0, + 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, + 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, + 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, + 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, + 234, 0, 235, 0, 0, 0, 238, 239, 528, 0, + 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, + 249, 250, 251, 252, 1317, 254, 0, 256, 257, 258, + 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, + 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, + 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, + 285, 286, 287, 288, 0, 0, 289, 0, 291, 0, + 0, 293, 294, 295, 296, 297, 298, 299, 300, 529, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 0, 324, 325, 326, 327, 328, 0, 329, 330, + 0, 332, 0, 333, 334, 335, 336, 337, 338, 0, + 339, 340, 0, 0, 341, 342, 343, 0, 0, 344, + 345, 346, 0, 348, 0, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, + 0, 362, 363, 364, 0, 366, 367, 368, 369, 370, + 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, + 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, + 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, + 398, 399, 400, 0, 401, 402, 0, 404, 405, 406, + 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, + 425, 426, 427, 428, 429, 0, 0, 431, 432, 433, + 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, + 443, 444, 445, 446, 530, 448, 449, 0, 0, 450, + 451, 0, 452, 0, 454, 455, 456, 457, 458, 0, + 459, 460, 461, 0, 0, 462, 463, 464, 465, 466, + 0, 467, 468, 469, 470, 471, 472, 473, 474, 0, + 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, + 482, 483, 484, 485, 486, 487, 488, 0, 489, 0, + 491, 492, 493, 494, 495, 496, 497, 0, 0, 498, + 0, 0, 499, 500, 501, 502, 503, 504, 505, 506, + 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, + 517, 518, 519, 527, 0, 553, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, + 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, + 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, + 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, + 153, 154, 155, 156, 0, 157, 158, 159, 160, 161, + 0, 0, 0, 163, 164, 165, 166, 167, 168, 0, + 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, + 0, 0, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, + 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, + 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, + 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, + 235, 0, 0, 0, 238, 239, 528, 0, 242, 0, + 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, + 251, 252, 1319, 254, 0, 256, 257, 258, 259, 0, + 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, + 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, + 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, + 287, 288, 0, 0, 289, 0, 291, 0, 0, 293, + 294, 295, 296, 297, 298, 299, 300, 529, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 322, 0, + 324, 325, 326, 327, 328, 0, 329, 330, 0, 332, + 0, 333, 334, 335, 336, 337, 338, 0, 339, 340, + 0, 0, 341, 342, 343, 0, 0, 344, 345, 346, + 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, + 363, 364, 0, 366, 367, 368, 369, 370, 371, 0, + 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, + 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, + 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, + 400, 0, 401, 402, 0, 404, 405, 406, 407, 408, + 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, + 419, 420, 0, 0, 421, 422, 423, 424, 425, 426, + 427, 428, 429, 0, 0, 431, 432, 433, 434, 0, + 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, + 445, 446, 530, 448, 449, 0, 0, 450, 451, 0, + 452, 0, 454, 455, 456, 457, 458, 0, 459, 460, + 461, 0, 0, 462, 463, 464, 465, 466, 0, 467, + 468, 469, 470, 471, 472, 473, 474, 0, 0, 475, + 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, + 484, 485, 486, 487, 488, 0, 489, 0, 491, 492, + 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, + 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, + 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, + 519, 527, 0, 553, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, + 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, + 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, + 147, 148, 149, 0, 0, 150, 151, 152, 153, 154, + 155, 156, 0, 157, 158, 159, 160, 161, 0, 0, + 0, 163, 164, 165, 166, 167, 168, 0, 170, 171, + 172, 0, 173, 174, 175, 176, 177, 178, 0, 0, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, + 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, + 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, + 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 0, 229, + 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, + 0, 0, 238, 239, 528, 0, 242, 0, 243, 0, + 244, 245, 246, 247, 0, 248, 249, 250, 251, 252, + 2246, 254, 0, 256, 257, 258, 259, 0, 260, 261, + 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, + 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, + 0, 0, 281, 0, 283, 284, 285, 286, 287, 288, + 0, 0, 289, 0, 291, 0, 0, 293, 294, 295, + 296, 297, 298, 299, 300, 529, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 0, 324, 325, + 326, 327, 328, 0, 329, 330, 0, 332, 0, 333, + 334, 335, 336, 337, 338, 0, 339, 340, 0, 0, + 341, 342, 343, 0, 0, 344, 345, 346, 0, 348, + 0, 350, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 360, 361, 0, 0, 0, 0, 362, 363, 364, + 0, 366, 367, 368, 369, 370, 371, 0, 372, 373, + 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, + 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, + 401, 402, 0, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, + 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, + 429, 0, 0, 431, 432, 433, 434, 0, 435, 436, + 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, + 530, 448, 449, 0, 0, 450, 451, 0, 452, 0, + 454, 455, 456, 457, 458, 0, 459, 460, 461, 0, + 0, 462, 463, 464, 465, 466, 0, 467, 468, 469, + 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, + 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, + 486, 487, 488, 0, 489, 0, 491, 492, 493, 494, + 495, 496, 497, 0, 0, 498, 0, 0, 499, 500, + 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, + 511, 512, 513, 514, 515, 516, 517, 518, 519, 1484, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, + 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, + 0, 0, 0, 1485, 0, 0, -793, 0, 1486, 130, + 131, 0, 132, 133, 134, 1487, 136, 137, 138, 0, + 1488, 1489, 1490, 1491, 0, 144, 145, 146, 147, 148, + 149, 0, 0, 150, 151, 152, 153, 1492, 1493, 156, + 0, 157, 158, 159, 160, 0, 0, 1494, 0, 1495, + 164, 165, 166, 167, 168, 1496, 170, 171, 172, 0, + 173, 174, 175, 176, 177, 178, 0, 1497, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 1498, 191, + 192, 1499, 194, 0, 195, 0, 196, 197, 198, 199, + 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, + 206, 207, 1063, 209, 210, 0, 211, 212, 213, 0, + 214, 215, 216, 0, 217, 218, 219, 220, 0, 222, + 223, 224, 225, 226, 227, 0, 0, 229, 0, 230, + 231, 1500, 233, 0, 234, 0, 235, 1501, 0, 1502, + 238, 239, -793, 1503, 242, 0, 243, 0, 0, 0, + 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, + 1504, 256, 257, 258, 259, 0, 260, 261, 262, 263, + 264, 265, 266, 0, 267, 1505, 0, 270, 271, 272, + 273, 274, 1506, 1507, 0, 1508, 0, 278, 1509, 1510, + 281, 1511, 283, 284, 285, 286, 287, 288, 0, 0, + 289, 1512, 291, 1513, 0, 293, 294, 295, 296, 297, + 298, 299, 300, 1514, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 1515, 1516, 1517, 325, 326, 327, + 0, 0, 329, 330, 1518, 332, 0, 0, 334, 1519, + 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, + 343, 0, 0, 344, 345, 0, 1520, 348, 1521, 0, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + 361, 0, 0, 0, 0, 362, 363, 0, 1522, 366, + 367, 0, 369, 370, 371, 0, 372, 373, 374, 375, + 376, 377, 0, 378, 379, 380, 381, 382, 1523, 384, + 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, + 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, + 1524, 404, 405, 406, 1525, 408, 409, 410, 411, 412, + 413, 414, 415, 416, 417, 418, 419, 420, 0, 1526, + 421, 422, 423, 424, 425, 426, 1527, 428, 429, 0, + 1528, 431, 432, 1529, 434, 0, 435, 436, 437, 438, + 439, 440, 441, 442, 443, 444, 445, 446, 1530, 448, + 0, 0, 0, 450, 451, 0, 452, 1531, 454, 455, + 456, 457, 458, 0, 459, 1532, 1533, 0, 0, 462, + 463, 0, 465, 0, 0, 467, 468, 1534, 470, 471, + 472, 473, 474, 1535, 0, 475, 476, 477, 0, 478, + 479, 480, 481, 0, 482, 483, 484, 485, 486, 0, + 1536, 0, 489, 1537, 491, 492, 493, 494, 495, 496, + 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, + 503, 504, 527, 0, 553, 0, 0, 0, 0, 0, + 0, 0, 0, 516, 517, 518, 519, 0, 0, 0, + 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, + 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, + 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, + 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, + 154, 155, 156, 0, 157, 158, 159, 160, 161, 0, + 0, 0, 163, 164, 165, 166, 167, 168, 0, 170, + 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, + 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, + 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, + 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, + 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 0, + 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, + 0, 0, 0, 238, 239, 528, 0, 242, 0, 243, + 0, 244, 245, 246, 247, 0, 248, 249, 250, 251, + 252, 2994, 254, 0, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, + 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, + 278, 0, 0, 281, 0, 283, 284, 285, 286, 287, + 288, 0, 0, 289, 0, 291, 0, 0, 293, 294, + 295, 296, 297, 298, 299, 300, 529, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 0, 324, + 325, 326, 327, 328, 0, 329, 330, 0, 332, 0, + 333, 334, 335, 336, 337, 338, 0, 339, 340, 0, + 0, 341, 342, 343, 0, 0, 344, 345, 346, 0, + 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, + 364, 0, 366, 367, 368, 369, 370, 371, 0, 372, + 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, + 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 0, 401, 402, 0, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 0, 0, 431, 432, 433, 434, 0, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, 530, 448, 449, 0, 0, 450, 451, 0, 452, + 0, 454, 455, 456, 457, 458, 0, 459, 460, 461, + 0, 0, 462, 463, 464, 465, 466, 0, 467, 468, + 469, 470, 471, 472, 473, 474, 0, 0, 475, 476, + 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, + 485, 486, 487, 488, 0, 489, 0, 491, 492, 493, + 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, + 527, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, + 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, + 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, + 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, + 148, 149, 0, 0, 150, 151, 152, 153, 154, 155, + 156, 0, 157, 158, 159, 160, 161, 0, 0, 0, + 163, 164, 165, 166, 167, 168, 0, 170, 171, 172, + 0, 173, 174, 175, 176, 177, 178, 0, 0, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, + 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, + 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, + 0, 214, 215, 216, 0, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 0, 229, 0, + 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, + 0, 238, 239, 528, 0, 242, 0, 243, 0, 244, + 245, 246, 247, 0, 248, 249, 250, 251, 252, 253, + 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, + 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, + 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, + 0, 281, 0, 283, 284, 285, 286, 287, 288, 0, + 0, 289, 0, 291, 0, 0, 293, 294, 295, 296, + 297, 298, 299, 300, 529, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, + 317, 318, 319, 320, 321, 322, 0, 324, 325, 326, + 327, 328, 0, 329, 330, 0, 332, 0, 333, 334, + 335, 336, 337, 338, 0, 339, 340, 0, 0, 341, + 342, 343, 0, 0, 344, 345, 346, 0, 348, 0, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, 361, 0, 0, 0, 0, 362, 363, 364, 0, + 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, + 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, + 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, + 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, + 402, 0, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, + 0, 421, 422, 423, 424, 425, 426, 427, 428, 429, + 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, + 438, 439, 440, 441, 442, 443, 444, 445, 446, 530, + 448, 449, 0, 0, 450, 451, 0, 452, 0, 454, + 455, 456, 457, 458, 0, 459, 460, 461, 0, 0, + 462, 463, 464, 465, 466, 0, 467, 468, 469, 470, + 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, + 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, + 487, 488, 0, 489, 0, 491, 492, 493, 494, 495, + 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, + 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, + 512, 513, 514, 515, 516, 517, 518, 519, 527, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, + 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, + 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, + 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, + 0, 0, 150, 151, 152, 153, 154, 155, 156, 0, + 157, 158, 159, 160, 161, 0, 0, 0, 163, 164, + 165, 166, 167, 168, 0, 170, 171, 172, 0, 173, + 174, 175, 176, 177, 178, 0, 0, 180, 181, 182, + 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, + 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, + 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, + 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, + 215, 216, 0, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, + 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, + 239, 528, 0, 840, 0, 243, 0, 244, 245, 246, + 247, 0, 248, 249, 250, 251, 252, 253, 254, 0, + 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, + 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, + 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, + 0, 283, 284, 285, 286, 287, 288, 0, 0, 289, + 0, 291, 0, 0, 293, 294, 841, 296, 297, 298, + 299, 300, 529, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 0, 324, 325, 326, 327, 328, + 0, 329, 330, 0, 332, 0, 333, 334, 335, 336, + 337, 338, 0, 339, 340, 0, 0, 341, 342, 343, + 0, 0, 344, 345, 346, 0, 348, 0, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, + 0, 0, 0, 0, 362, 363, 364, 0, 366, 367, + 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, + 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, + 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, + 395, 396, 397, 398, 399, 400, 0, 401, 402, 0, + 404, 405, 406, 407, 408, 409, 410, 411, 842, 413, + 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, + 422, 423, 424, 843, 426, 427, 428, 429, 0, 0, + 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, + 440, 441, 442, 443, 444, 445, 446, 530, 448, 449, + 0, 0, 450, 451, 0, 452, 0, 454, 455, 456, + 457, 458, 0, 459, 844, 461, 0, 0, 462, 463, + 464, 465, 466, 0, 467, 468, 469, 470, 471, 472, + 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, + 480, 481, 0, 482, 483, 484, 485, 486, 487, 488, + 0, 489, 0, 491, 492, 493, 494, 495, 496, 497, + 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, + 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, + 514, 515, 516, 517, 518, 519, 527, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, + 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, + 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, + 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, + 150, 151, 152, 153, 154, 155, 156, 0, 157, 158, + 159, 160, 161, 0, 0, 0, 163, 164, 165, 166, + 167, 168, 0, 170, 171, 172, 0, 173, 174, 175, + 176, 177, 178, 0, 0, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, + 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, + 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, + 0, 217, 218, 219, 220, 221, 222, 223, 224, 225, + 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, + 0, 234, 0, 235, 0, 0, 0, 238, 239, 528, + 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, + 248, 249, 250, 251, 252, 956, 254, 0, 256, 257, + 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, + 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, + 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, + 284, 285, 286, 287, 288, 0, 0, 289, 0, 291, + 0, 0, 293, 294, 295, 296, 297, 298, 299, 300, + 529, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 0, 324, 325, 326, 327, 328, 0, 329, + 330, 0, 332, 0, 333, 334, 335, 336, 337, 338, + 0, 339, 340, 0, 0, 341, 342, 343, 0, 0, + 344, 345, 346, 0, 348, 0, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, + 0, 0, 362, 363, 364, 0, 366, 367, 368, 369, + 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, + 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, + 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, + 397, 398, 399, 400, 0, 401, 402, 0, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, + 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, + 424, 425, 426, 427, 428, 429, 0, 0, 431, 432, + 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, + 442, 443, 444, 445, 446, 530, 448, 449, 0, 0, + 450, 451, 0, 452, 0, 454, 455, 456, 457, 458, + 0, 459, 460, 461, 0, 0, 462, 463, 464, 465, + 466, 0, 467, 468, 469, 470, 471, 472, 473, 474, + 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, + 0, 482, 483, 484, 485, 486, 487, 488, 0, 489, + 0, 491, 492, 493, 494, 495, 496, 497, 0, 0, + 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, + 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, + 516, 517, 518, 519, 527, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, + 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, + 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, + 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, + 152, 153, 154, 155, 156, 0, 157, 158, 159, 160, + 161, 0, 0, 0, 163, 164, 165, 166, 167, 168, + 0, 170, 171, 172, 0, 173, 174, 175, 176, 177, + 178, 0, 0, 180, 181, 182, 183, 184, 185, 186, + 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, + 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, + 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, + 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, + 0, 235, 0, 0, 0, 238, 239, 528, 0, 242, + 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, + 250, 251, 252, 253, 254, 0, 256, 257, 258, 259, + 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, + 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, + 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, + 286, 287, 288, 0, 0, 289, 0, 291, 0, 0, + 293, 294, 295, 296, 297, 298, 299, 300, 529, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, + 0, 324, 325, 326, 327, 328, 0, 329, 330, 0, + 332, 0, 333, 334, 335, 336, 337, 338, 0, 339, + 340, 0, 0, 341, 342, 343, 0, 0, 344, 345, + 346, 0, 348, 0, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, + 362, 363, 364, 0, 366, 367, 368, 369, 370, 371, + 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, + 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, + 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, + 399, 400, 0, 401, 402, 0, 404, 405, 406, 407, + 408, 409, 410, 411, 842, 413, 414, 415, 416, 417, + 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, + 426, 427, 428, 429, 0, 0, 431, 432, 433, 434, + 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, + 444, 445, 446, 530, 448, 449, 0, 0, 450, 451, + 0, 452, 0, 454, 455, 456, 457, 458, 0, 459, + 844, 461, 0, 0, 462, 463, 464, 465, 466, 0, + 467, 468, 469, 470, 471, 472, 473, 474, 0, 0, + 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, + 483, 484, 485, 486, 487, 488, 0, 489, 0, 491, + 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, + 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, + 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, + 518, 519, 527, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, + 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, + 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, + 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, + 154, 155, 156, 0, 157, 158, 159, 160, 161, 0, + 0, 0, 163, 164, 165, 166, 167, 168, 0, 170, + 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, + 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, + 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, + 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, + 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 0, + 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, + 0, 0, 0, 238, 239, 528, 0, 242, 0, 243, + 0, 244, 245, 246, 247, 0, 248, 249, 250, 251, + 252, 1308, 254, 0, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, + 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, + 278, 0, 0, 281, 0, 283, 284, 285, 286, 287, + 288, 0, 0, 289, 0, 291, 0, 0, 293, 294, + 295, 296, 297, 298, 299, 300, 529, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - -1, -1, -1, -1, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, - 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, - 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, -1, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, - 385, 386, 387, 388, 389, 390, 391, 392, -1, -1, - 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, - -1, -1, 417, 418, -1, 420, 421, 422, 423, 424, - 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, - 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, - 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, - -1, 466, 467, 468, 469, 470, 471, 472, 473, 474, - -1, -1, 477, -1, -1, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 499, 500, -1, -1, -1, -1, - -1, -1, -1, 508, 509, 510, -1, 3, 4, 5, - 515, -1, 517, 9, -1, -1, -1, 522, 523, -1, - 525, 526, -1, -1, -1, -1, 22, 23, 24, 25, - 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, - -1, 37, -1, -1, -1, -1, 42, 43, 44, -1, - 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, - -1, 67, 68, 69, 70, 71, 72, 73, -1, 75, - 76, 77, 78, 79, -1, 81, -1, 83, 84, 85, - 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, - 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, - 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, - 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, - -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, - 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, - 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, 160, 161, -1, 163, 164, 165, - 166, -1, 168, -1, 170, 171, -1, 173, 174, 175, - 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, - -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, - 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, - 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, - 216, 217, -1, 219, -1, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, 231, -1, -1, 234, 235, - 236, 237, -1, 239, 240, 241, 242, 243, 244, 245, - 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, - 266, 267, 268, 269, 270, 271, 272, 273, 274, -1, - 276, 277, 278, 279, -1, 281, 282, 283, 284, 285, - 286, -1, 288, 289, 290, -1, 292, 293, 294, -1, - -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, - -1, -1, -1, 319, 320, 321, 322, 323, 324, 325, - 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, - -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, - 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, - 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, - 376, 377, 378, 379, 380, 381, -1, 383, 384, 385, - 386, 387, 388, 389, 390, 391, 392, -1, 394, 395, - 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, - -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, - 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 315, 316, 317, 318, 319, 320, 321, 322, 0, 324, + 325, 326, 327, 328, 0, 329, 330, 0, 332, 0, + 333, 334, 335, 336, 337, 338, 0, 339, 340, 0, + 0, 341, 342, 343, 0, 0, 344, 345, 346, 0, + 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, + 364, 0, 366, 367, 368, 369, 370, 371, 0, 372, + 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, + 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 0, 401, 402, 0, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, - 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, - 456, -1, 458, 459, 460, 461, 462, 463, 464, -1, - 466, 467, 468, 469, 470, 471, 472, 473, 474, -1, - -1, 477, -1, -1, 480, 481, 482, 483, 484, 485, - 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, - 496, 497, 498, 499, 500, -1, -1, -1, -1, 3, - -1, -1, 508, 509, 510, -1, -1, -1, -1, 515, - -1, 517, -1, -1, -1, -1, -1, 523, 22, 23, - 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, - -1, -1, -1, -1, -1, -1, 40, -1, -1, 43, - 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, - 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, - 64, -1, -1, 67, 68, 69, 70, 71, 72, 73, - -1, 75, 76, 77, 78, 79, -1, -1, -1, 83, - 84, 85, 86, 87, 88, -1, 90, 91, 92, -1, - 94, 95, 96, 97, 98, 99, -1, -1, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, - 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, - 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, - 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, -1, 161, 162, 163, - 164, 165, 166, 167, 168, -1, 170, -1, -1, -1, - 174, 175, 176, -1, 178, -1, 180, -1, 182, 183, - 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, - -1, 195, 196, 197, 198, -1, 200, 201, 202, 203, - 204, 205, 206, -1, 208, -1, 210, 211, 212, 213, - 214, 215, 216, 217, 218, 219, -1, 221, -1, -1, - 224, -1, 226, 227, 228, 229, 230, 231, -1, -1, - 234, -1, 236, -1, 238, 239, 240, 241, 242, 243, - 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, - 264, 265, 266, 267, 268, -1, 270, 271, 272, 273, - 274, -1, 276, 277, -1, 279, -1, 281, 282, 283, - 284, 285, 286, 287, 288, 289, -1, -1, 292, 293, - 294, -1, 296, 297, 298, 299, -1, 301, -1, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, -1, -1, -1, -1, 319, 320, 321, -1, 323, - 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, - 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, - 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, - -1, 365, 366, 367, 368, 369, 370, 371, 372, 373, - 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, - 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, - -1, 395, 396, 397, 398, -1, 400, 401, 402, 403, + 446, 530, 448, 449, 0, 0, 450, 451, 0, 452, + 0, 454, 455, 456, 457, 458, 0, 459, 460, 461, + 0, 0, 462, 463, 464, 465, 466, 0, 467, 468, + 469, 470, 471, 472, 473, 474, 0, 0, 475, 476, + 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, + 485, 486, 487, 488, 0, 489, 0, 491, 492, 493, + 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, + 527, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, + 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, + 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, + 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, + 148, 149, 0, 0, 150, 151, 152, 153, 154, 155, + 156, 0, 157, 158, 159, 160, 161, 0, 0, 0, + 163, 164, 165, 166, 167, 168, 0, 170, 171, 172, + 0, 173, 174, 175, 176, 177, 178, 0, 0, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, + 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, + 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, + 0, 214, 215, 216, 0, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 0, 229, 0, + 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, + 0, 238, 239, 528, 0, 242, 0, 243, 0, 244, + 245, 246, 247, 0, 248, 249, 250, 251, 252, 1329, + 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, + 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, + 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, + 0, 281, 0, 283, 284, 285, 286, 287, 288, 0, + 0, 289, 0, 291, 0, 0, 293, 294, 295, 296, + 297, 298, 299, 300, 529, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, + 317, 318, 319, 320, 321, 322, 0, 324, 325, 326, + 327, 328, 0, 329, 330, 0, 332, 0, 333, 334, + 335, 336, 337, 338, 0, 339, 340, 0, 0, 341, + 342, 343, 0, 0, 344, 345, 346, 0, 348, 0, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, 361, 0, 0, 0, 0, 362, 363, 364, 0, + 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, + 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, + 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, + 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, + 402, 0, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, + 0, 421, 422, 423, 424, 425, 426, 427, 428, 429, + 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, + 438, 439, 440, 441, 442, 443, 444, 445, 446, 530, + 448, 449, 0, 0, 450, 451, 0, 452, 0, 454, + 455, 456, 457, 458, 0, 459, 460, 461, 0, 0, + 462, 463, 464, 465, 466, 0, 467, 468, 469, 470, + 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, + 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, + 487, 488, 0, 489, 0, 491, 492, 493, 494, 495, + 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, + 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, + 512, 513, 514, 515, 516, 517, 518, 519, 527, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, + 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, + 0, 0, 0, 0, 0, 1679, 0, 0, 130, 131, + 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, + 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, + 0, 0, 150, 151, 152, 153, 154, 155, 156, 0, + 157, 158, 159, 160, 161, 0, 0, 0, 163, 164, + 165, 166, 167, 168, 0, 170, 171, 172, 0, 173, + 174, 175, 176, 177, 178, 0, 0, 180, 181, 182, + 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, + 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, + 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, + 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, + 215, 216, 0, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, + 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, + 239, 528, 0, 242, 0, 243, 0, 244, 245, 246, + 247, 0, 248, 249, 250, 251, 252, 253, 254, 0, + 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, + 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, + 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, + 0, 283, 284, 285, 286, 287, 288, 0, 0, 289, + 0, 291, 0, 0, 293, 294, 295, 296, 297, 298, + 299, 300, 529, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 0, 324, 325, 326, 327, 328, + 0, 329, 330, 0, 332, 0, 333, 334, 335, 336, + 337, 338, 0, 339, 340, 0, 0, 341, 342, 343, + 0, 0, 344, 345, 346, 0, 348, 0, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, + 0, 0, 0, 0, 362, 363, 364, 0, 366, 367, + 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, + 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, + 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, + 395, 396, 397, 398, 399, 400, 0, 401, 402, 0, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, -1, -1, 417, 418, -1, 420, -1, 422, 423, - 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, - 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, - 444, 445, 446, 447, -1, 449, 450, 451, -1, 453, - 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, - 464, -1, 466, -1, 468, 469, 470, 471, 472, 473, - 474, -1, -1, 477, -1, -1, 480, 481, 482, 483, - 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, - 494, 495, 496, 497, 498, 499, 500, 3, -1, 5, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 518, -1, 22, 23, 24, 25, - 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, - 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, - 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, - -1, 67, 68, 69, 70, 71, 72, 73, -1, 75, - 76, 77, 78, 79, -1, -1, -1, 83, 84, 85, - 86, 87, 88, -1, 90, 91, 92, -1, 94, 95, - 96, 97, 98, 99, -1, -1, 102, 103, 104, 105, - 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, - 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, - -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, - 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, - 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, -1, 161, -1, 163, 164, 165, - 166, -1, 168, -1, 170, -1, -1, -1, 174, 175, - 176, -1, 178, -1, 180, -1, 182, 183, 184, 185, - -1, 187, 188, 189, 190, 191, 192, 193, -1, 195, - 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, - 206, -1, 208, -1, 210, 211, 212, 213, 214, 215, - 216, 217, -1, 219, -1, 221, -1, -1, 224, -1, - 226, 227, 228, 229, 230, 231, -1, -1, 234, -1, - 236, -1, -1, 239, 240, 241, 242, 243, 244, 245, - 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, - 266, 267, 268, -1, 270, 271, 272, 273, 274, -1, - 276, 277, -1, 279, -1, 281, 282, 283, 284, 285, - 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, - -1, 297, 298, 299, -1, 301, -1, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, - -1, -1, -1, 319, 320, 321, -1, 323, 324, 325, - 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, - -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, - 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, -1, 362, 363, -1, 365, - 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, - 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, - 386, 387, 388, 389, 390, 391, 392, -1, -1, 395, - 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, - -1, 417, 418, -1, 420, -1, 422, 423, 424, 425, - 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, - 436, 437, -1, 439, 440, 441, 442, 443, 444, 445, - 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, - 456, -1, 458, 459, 460, 461, 462, 463, 464, -1, - 466, -1, 468, 469, 470, 471, 472, 473, 474, -1, - -1, 477, -1, -1, 480, 481, 482, 483, 484, 485, - 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, - 496, 497, 498, 499, 500, 3, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 517, 518, -1, 22, 23, 24, 25, 26, 27, - 28, 29, -1, 31, 32, 33, 34, 35, -1, 37, - -1, -1, -1, -1, 42, 43, 44, -1, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, - 68, 69, 70, 71, 72, 73, -1, 75, 76, 77, - 78, 79, -1, 81, -1, 83, 84, 85, 86, 87, - 88, 89, 90, 91, 92, -1, 94, 95, 96, 97, - 98, 99, -1, 101, 102, 103, 104, 105, 106, 107, - 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, - 118, -1, 120, 121, 122, 123, 124, 125, 126, 127, - 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, - 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, - 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, -1, 161, -1, 163, 164, 165, 166, -1, - 168, -1, 170, 171, 172, 173, 174, 175, 176, 177, - 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 198, -1, 200, 201, 202, 203, 204, 205, 206, -1, - 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, - -1, 219, -1, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, -1, -1, 234, 235, 236, 237, - -1, 239, 240, 241, 242, 243, 244, 245, 246, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, 273, 274, -1, 276, 277, - 278, 279, -1, 281, 282, 283, 284, 285, 286, -1, - 288, 289, -1, -1, 292, 293, 294, -1, -1, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - -1, 319, 320, 321, 322, 323, 324, 325, 326, 327, - 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, - 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, -1, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, + 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, + 422, 423, 424, 425, 0, 427, 428, 429, 0, 0, + 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, + 440, 441, 442, 443, 444, 445, 446, 530, 448, 449, + 0, 0, 450, 451, 0, 452, 0, 454, 455, 456, + 457, 458, 0, 459, 460, 461, 0, 0, 462, 463, + 464, 465, 466, 0, 467, 468, 469, 470, 471, 472, + 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, + 480, 481, 0, 482, 483, 484, 485, 486, 487, 488, + 0, 489, 0, 491, 492, 493, 494, 495, 496, 497, + 0, 0, 498, 0, 0, 499, 500, 501, 502, 503, + 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, + 514, 515, 516, 517, 518, 519, 527, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, + 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, + 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, + 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, + 150, 151, 152, 153, 154, 155, 156, 0, 157, 158, + 159, 160, 161, 0, 0, 0, 163, 164, 165, 166, + 167, 168, 0, 170, 171, 172, 0, 173, 174, 175, + 176, 177, 178, 0, 0, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, + 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, + 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, + 0, 217, 218, 219, 220, 221, 222, 223, 224, 225, + 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, + 0, 234, 0, 235, 0, 0, 0, 238, 239, 528, + 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, + 248, 249, 250, 251, 252, 1859, 254, 0, 256, 257, + 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, + 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, + 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, + 284, 285, 286, 287, 288, 0, 0, 289, 0, 291, + 0, 0, 293, 294, 295, 296, 297, 298, 299, 300, + 529, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 0, 324, 325, 326, 327, 328, 0, 329, + 330, 0, 332, 0, 333, 334, 335, 336, 337, 338, + 0, 339, 340, 0, 0, 341, 342, 343, 0, 0, + 344, 345, 346, 0, 348, 0, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, + 0, 0, 362, 363, 364, 0, 366, 367, 368, 369, + 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, - 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, - 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, 412, 413, 414, 415, -1, 417, - 418, 419, 420, 421, 422, 423, 424, 425, 426, -1, - 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, - -1, 439, 440, 441, 442, 443, 444, 445, 446, -1, - -1, 449, 450, 451, 452, 453, 454, 455, 456, -1, - 458, 459, 460, 461, 462, 463, 464, -1, 466, 467, - 468, 469, 470, 471, 472, 473, 474, -1, -1, 477, - -1, 479, 480, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 498, 499, 500, -1, 3, 503, 5, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 517, - -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, - 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, - -1, -1, -1, 42, 43, 44, -1, 46, 47, 48, - 49, 50, 51, 52, 53, 54, 55, 56, 57, -1, - 59, 60, 61, 62, 63, 64, -1, 66, 67, 68, - 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, - 79, -1, 81, -1, 83, 84, 85, 86, 87, 88, - 89, 90, 91, 92, -1, 94, 95, 96, 97, 98, - 99, -1, 101, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, - -1, 120, 121, 122, 123, 124, 125, 126, 127, 128, - 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, - -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, - 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, -1, 161, -1, 163, 164, 165, 166, -1, 168, - -1, 170, 171, 172, 173, 174, 175, 176, 177, 178, - -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, - 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, - -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, - 209, 210, 211, 212, 213, 214, 215, 216, 217, -1, - 219, -1, 221, 222, 223, 224, 225, 226, 227, 228, - 229, 230, 231, 232, -1, 234, 235, 236, 237, -1, - 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, 274, -1, 276, 277, 278, - 279, -1, 281, 282, 283, 284, 285, 286, -1, 288, - 289, -1, 291, 292, 293, 294, -1, -1, 297, 298, - 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, -1, - 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, - 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, - 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, - 379, 380, 381, 382, -1, 384, 385, 386, 387, 388, + 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, + 397, 398, 399, 400, 0, 401, 402, 0, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, + 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, + 424, 425, 426, 427, 428, 429, 0, 0, 431, 432, + 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, + 442, 443, 444, 445, 446, 530, 448, 449, 0, 0, + 450, 451, 0, 452, 0, 454, 455, 456, 457, 458, + 0, 459, 460, 461, 0, 0, 462, 463, 464, 465, + 466, 0, 467, 468, 469, 470, 471, 472, 473, 474, + 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, + 0, 482, 483, 484, 485, 486, 487, 488, 0, 489, + 0, 491, 492, 493, 494, 495, 496, 497, 0, 0, + 498, 0, 0, 499, 500, 501, 502, 503, 504, 505, + 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, + 516, 517, 518, 519, 527, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, + 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, + 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, + 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, + 152, 153, 154, 155, 156, 0, 157, 158, 159, 160, + 161, 0, 0, 0, 163, 164, 165, 166, 167, 168, + 0, 170, 171, 172, 0, 173, 174, 175, 176, 177, + 178, 0, 0, 180, 181, 182, 183, 184, 185, 186, + 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, + 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, + 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, + 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, + 0, 235, 0, 0, 0, 238, 239, 528, 0, 242, + 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, + 250, 251, 252, 2233, 254, 0, 256, 257, 258, 259, + 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, + 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, + 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, + 286, 287, 288, 0, 0, 289, 0, 291, 0, 0, + 293, 294, 295, 296, 297, 298, 299, 300, 529, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, + 0, 324, 325, 326, 327, 328, 0, 329, 330, 0, + 332, 0, 333, 334, 335, 336, 337, 338, 0, 339, + 340, 0, 0, 341, 342, 343, 0, 0, 344, 345, + 346, 0, 348, 0, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, + 362, 363, 364, 0, 366, 367, 368, 369, 370, 371, + 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, + 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, - -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, 412, 413, 414, 415, -1, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 426, -1, 428, - 429, 430, -1, -1, 433, 434, 435, 436, 437, -1, - 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, - 449, 450, 451, 452, 453, 454, 455, 456, -1, 458, - 459, 460, 461, 462, 463, 464, -1, 466, 467, 468, - 469, 470, 471, 472, 473, 474, -1, -1, 477, -1, - 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, - 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, - 499, 500, -1, 3, 503, 5, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 517, -1, - -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, - -1, 31, 32, 33, -1, -1, -1, -1, -1, -1, - -1, -1, 42, 43, 44, -1, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, - 60, 61, 62, 63, 64, -1, 66, 67, 68, 69, - 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, - -1, 81, -1, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, - -1, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, - 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, - 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, - 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - -1, 161, -1, 163, 164, 165, 166, -1, 168, -1, - 170, 171, -1, 173, 174, 175, 176, 177, 178, -1, - 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, -1, - 200, 201, 202, 203, 204, 205, 206, -1, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, - -1, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, 232, -1, 234, 235, 236, 237, -1, 239, - 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, - 270, 271, 272, 273, 274, -1, 276, 277, 278, 279, - -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, - -1, 291, 292, 293, 294, -1, -1, 297, 298, 299, - 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, - 320, 321, 322, 323, 324, 325, 326, 327, 328, -1, - 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, - 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, - 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, - 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, - 380, 381, -1, -1, 384, 385, 386, 387, 388, 389, - 390, 391, 392, -1, 394, 395, 396, 397, 398, -1, - 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, - 410, 411, 412, 413, 414, -1, -1, 417, 418, -1, - 420, 421, 422, 423, 424, 425, 426, -1, 428, 429, - 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, - 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, - 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, - 460, 461, 462, 463, 464, -1, 466, 467, 468, 469, - 470, 471, 472, 473, 474, -1, -1, 477, -1, -1, - 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, - 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, - 500, 3, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 517, -1, -1, - 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, - 32, 33, -1, -1, -1, -1, -1, -1, -1, -1, - 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, - 62, 63, 64, -1, 66, 67, 68, 69, 70, 71, - 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, - -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, - 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, - -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, - 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, -1, 161, - -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, - -1, 173, 174, 175, 176, 177, 178, -1, 180, -1, - 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, - 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - -1, -1, 234, 235, 236, 237, -1, 239, 240, 241, - 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, - 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, - 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, - 272, 273, 274, -1, 276, 277, 278, 279, -1, 281, - 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, - 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, - 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, - 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, - 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, - 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, - 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, -1, -1, 417, 418, -1, 420, 421, - 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, - -1, 433, 434, 435, 436, 437, -1, 439, 440, 441, - 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, - -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, - 462, 463, 464, -1, 466, 467, 468, 469, 470, 471, - 472, 473, 474, -1, -1, 477, -1, -1, 480, 481, - 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 498, 499, 500, 3, + 399, 400, 0, 401, 402, 0, 404, 405, 406, 407, + 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, + 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, + 426, 427, 428, 429, 0, 0, 431, 432, 433, 434, + 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, + 444, 445, 446, 530, 448, 449, 0, 0, 450, 451, + 0, 452, 0, 454, 455, 456, 457, 458, 0, 459, + 460, 461, 0, 0, 462, 463, 464, 465, 466, 0, + 467, 468, 469, 470, 471, 472, 473, 474, 0, 0, + 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, + 483, 484, 485, 486, 487, 488, 0, 489, 0, 491, + 492, 493, 494, 495, 496, 497, 0, 0, 498, 0, + 0, 499, 500, 501, 502, 503, 504, 505, 506, 507, + 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, + 518, 519, 527, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, + 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, + 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, + 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, + 154, 155, 156, 0, 157, 158, 159, 160, 161, 0, + 0, 0, 163, 164, 165, 166, 167, 168, 0, 170, + 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, + 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, + 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, + 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, + 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 0, + 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, + 0, 0, 0, 238, 239, 528, 0, 242, 0, 243, + 0, 244, 245, 246, 247, 0, 248, 249, 250, 251, + 252, 2248, 254, 0, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, + 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, + 278, 0, 0, 281, 0, 283, 284, 285, 286, 287, + 288, 0, 0, 289, 0, 291, 0, 0, 293, 294, + 295, 296, 297, 298, 299, 300, 529, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 0, 324, + 325, 326, 327, 328, 0, 329, 330, 0, 332, 0, + 333, 334, 335, 336, 337, 338, 0, 339, 340, 0, + 0, 341, 342, 343, 0, 0, 344, 345, 346, 0, + 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, + 364, 0, 366, 367, 368, 369, 370, 371, 0, 372, + 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, + 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 0, 401, 402, 0, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 0, 0, 431, 432, 433, 434, 0, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, 530, 448, 449, 0, 0, 450, 451, 0, 452, + 0, 454, 455, 456, 457, 458, 0, 459, 460, 461, + 0, 0, 462, 463, 464, 465, 466, 0, 467, 468, + 469, 470, 471, 472, 473, 474, 0, 0, 475, 476, + 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, + 485, 486, 487, 488, 0, 489, 0, 491, 492, 493, + 494, 495, 496, 497, 0, 0, 498, 0, 0, 499, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, + 1484, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, + 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, + 128, 0, 0, 0, 1485, 0, 0, 0, 0, 1486, + 130, 131, 0, 132, 133, 134, 1487, 136, 137, 138, + 0, 1488, 1489, 1490, 1491, 0, 144, 145, 146, 147, + 148, 149, 0, 0, 150, 151, 152, 153, 1492, 1493, + 156, 0, 157, 158, 159, 160, 0, 0, 1494, 0, + 1495, 164, 165, 166, 167, 168, 1496, 170, 171, 172, + 0, 173, 174, 175, 176, 177, 178, 0, 1497, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 1498, + 191, 192, 1499, 194, 0, 195, 0, 196, 197, 198, + 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, + 0, 206, 207, 1063, 209, 210, 0, 211, 212, 213, + 0, 214, 215, 216, 0, 217, 218, 219, 220, 0, + 222, 223, 224, 225, 226, 227, 0, 0, 229, 0, + 230, 231, 1500, 233, 0, 234, 0, 235, 1501, 0, + 1502, 238, 239, 0, 1503, 242, 0, 243, 0, 0, + 0, 246, 247, 0, 248, 249, 250, 251, 252, 253, + 254, 1504, 256, 257, 258, 259, 0, 260, 261, 262, + 263, 264, 265, 266, 0, 267, 1505, 0, 270, 271, + 272, 273, 274, 1506, 1507, 0, 1508, 0, 278, 1509, + 1510, 281, 1511, 283, 284, 285, 286, 287, 288, 0, + 0, 289, 1512, 291, 1513, 0, 293, 294, 295, 296, + 297, 298, 299, 300, 1514, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, + 317, 318, 319, 320, 321, 1515, 1516, 1517, 325, 326, + 327, 0, 0, 329, 330, 1518, 332, 0, 0, 334, + 1519, 336, 337, 338, 0, 339, 340, 0, 0, 341, + 342, 343, 0, 0, 344, 345, 0, 1520, 348, 1521, + 0, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, 361, 0, 0, 0, 0, 362, 363, 0, 1522, + 366, 367, 0, 369, 370, 371, 0, 372, 373, 374, + 375, 376, 377, 0, 378, 379, 380, 381, 382, 1523, + 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, + 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, + 402, 1524, 404, 405, 406, 1525, 408, 409, 410, 411, + 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, + 1526, 421, 422, 423, 424, 425, 426, 1527, 428, 429, + 0, 1528, 431, 432, 1529, 434, 0, 435, 436, 437, + 438, 439, 440, 441, 442, 443, 444, 445, 446, 1530, + 448, 0, 0, 0, 450, 451, 0, 452, 1531, 454, + 455, 456, 457, 458, 0, 459, 1532, 1533, 0, 0, + 462, 463, 0, 465, 0, 0, 467, 468, 1534, 470, + 471, 472, 473, 474, 1535, 0, 475, 476, 477, 0, + 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, + 0, 1536, 0, 489, 1537, 491, 492, 493, 494, 495, + 496, 497, 0, 0, 498, 0, 0, 499, 500, 501, + 502, 503, 504, 1484, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 516, 517, 518, 519, 0, 0, + 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, + 0, 126, 127, 128, 0, 0, 0, 1485, 0, 0, + 0, 0, 1486, 130, 131, 0, 132, 133, 134, 1487, + 136, 137, 138, 0, 1488, 1489, 1490, 1491, 0, 144, + 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, + 153, 1492, 1493, 156, 0, 157, 158, 159, 160, 0, + 0, 1494, 0, 1495, 164, 165, 166, 167, 168, 1496, + 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, + 0, 1497, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 1498, 191, 192, 1499, 194, 0, 195, 0, + 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, + 204, 205, 0, 0, 206, 207, 1063, 209, 210, 0, + 211, 212, 213, 0, 1841, 215, 216, 0, 217, 218, + 219, 220, 0, 222, 223, 224, 225, 226, 227, 0, + 0, 229, 0, 230, 231, 1500, 233, 0, 234, 0, + 235, 1501, 0, 1502, 238, 239, 0, 1503, 242, 0, + 243, 0, 0, 0, 246, 247, 0, 248, 249, 250, + 251, 252, 253, 254, 1504, 256, 257, 258, 259, 0, + 260, 261, 262, 263, 264, 265, 266, 0, 267, 1505, + 0, 270, 271, 272, 273, 274, 1506, 1507, 0, 1508, + 0, 278, 1509, 1510, 281, 1511, 283, 284, 285, 286, + 287, 288, 0, 0, 289, 1512, 291, 1513, 0, 293, + 294, 295, 296, 297, 298, 299, 300, 1514, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 1515, 1516, + 1517, 325, 326, 327, 0, 0, 329, 330, 1518, 332, + 0, 0, 334, 1519, 336, 337, 338, 0, 339, 340, + 0, 0, 341, 342, 343, 0, 0, 344, 345, 0, + 1520, 348, 1521, 0, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, + 363, 0, 1522, 366, 367, 0, 369, 370, 371, 0, + 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, + 381, 382, 1523, 384, 385, 386, 387, 0, 388, 389, + 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, + 400, 0, 401, 402, 1524, 404, 405, 406, 1525, 408, + 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, + 419, 420, 0, 1526, 421, 422, 423, 424, 425, 426, + 1527, 428, 429, 0, 1528, 431, 432, 1529, 434, 0, + 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, + 445, 446, 1530, 448, 0, 0, 0, 450, 451, 0, + 452, 1531, 454, 455, 456, 457, 458, 0, 459, 1532, + 1533, 0, 0, 462, 463, 0, 465, 0, 0, 467, + 468, 1534, 470, 471, 472, 473, 474, 1535, 0, 475, + 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, + 484, 485, 486, 0, 1536, 0, 489, 1537, 491, 492, + 493, 494, 495, 496, 497, 0, 0, 498, 0, 0, + 499, 500, 501, 502, 503, 504, 3164, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 516, 517, 518, + 519, 0, 0, 0, 0, 118, 119, 120, 121, 122, + 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, + 2916, 0, 0, 0, 0, 2917, 130, 131, 0, 132, + 133, 134, 2918, 136, 137, 138, 0, 1488, 2919, 1490, + 1491, 0, 144, 145, 146, 147, 148, 149, 0, 0, + 150, 151, 152, 153, 1492, 1493, 156, 0, 157, 158, + 159, 160, 0, 0, 2920, 0, 2921, 164, 165, 166, + 167, 168, 2922, 170, 171, 172, 0, 173, 174, 175, + 176, 177, 178, 0, 2923, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 189, 1498, 191, 192, 1499, 194, + 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, + 0, 202, 203, 204, 205, 0, 0, 206, 207, 1063, + 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, + 0, 217, 218, 219, 220, 0, 222, 223, 224, 225, + 226, 227, 0, 0, 229, 0, 230, 231, 1500, 233, + 0, 234, 0, 235, 2924, 0, 2925, 238, 239, 2926, + 2927, 242, 0, 243, 0, 0, 0, 246, 247, 0, + 248, 249, 250, 251, 252, 253, 254, 2928, 256, 257, + 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, + 0, 267, 2929, 0, 270, 271, 272, 273, 274, 1506, + 1507, 0, 1508, 0, 278, 2930, 2931, 281, 2932, 283, + 284, 285, 286, 287, 288, 0, 0, 289, 2933, 291, + 2934, 0, 293, 294, 295, 296, 297, 298, 299, 300, + 3165, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 1515, 2936, 1517, 325, 326, 327, 0, 0, 329, + 330, 2938, 332, 0, 0, 334, 1519, 336, 337, 338, + 0, 339, 340, 0, 0, 341, 342, 343, 0, 0, + 344, 345, 0, 2940, 348, 2941, 0, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, + 0, 0, 362, 363, 0, 2942, 366, 367, 0, 369, + 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, + 378, 379, 380, 381, 382, 1523, 384, 385, 386, 387, + 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, + 397, 398, 399, 400, 0, 401, 402, 2943, 404, 405, + 406, 0, 408, 409, 410, 411, 412, 413, 414, 415, + 416, 417, 418, 419, 420, 0, 2944, 421, 422, 423, + 424, 425, 426, 0, 428, 429, 0, 2946, 431, 432, + 1529, 434, 0, 435, 436, 437, 438, 439, 440, 441, + 442, 443, 444, 445, 446, 3166, 448, 0, 0, 0, + 450, 451, 0, 452, 2948, 454, 455, 456, 457, 458, + 0, 459, 1532, 1533, 0, 0, 462, 463, 0, 465, + 0, 0, 467, 468, 2949, 470, 471, 472, 473, 474, + 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, + 0, 482, 483, 484, 485, 486, 0, 1536, 0, 489, + 2951, 491, 492, 493, 494, 495, 496, 497, 0, 0, + 498, 0, 0, 499, 500, 501, 502, 503, 504, 527, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 516, 517, 518, 519, 0, 0, 0, 0, 118, 119, + 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, + 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, + 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, + 149, 0, 0, 150, 151, 152, 153, 154, 155, 156, + 0, 157, 158, 159, 160, 161, 0, 0, 0, 163, + 164, 165, 166, 167, 168, 0, 170, 171, 172, 0, + 173, 174, 175, 176, 177, 178, 0, 0, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, + 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, + 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, + 214, 215, 216, 0, 217, 218, 219, 220, 221, 222, + 223, 224, 225, 226, 227, 228, 0, 229, 0, 230, + 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, + 238, 239, 528, 0, 242, 0, 243, 0, 244, 245, + 0, 247, 0, 248, 249, 250, 251, 252, 253, 254, + 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, + 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, + 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, + 281, 0, 283, 284, 285, 286, 287, 288, 0, 0, + 289, 0, 291, 0, 0, 293, 294, 295, 296, 297, + 298, 299, 300, 529, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 0, 324, 325, 326, 327, + 328, 0, 329, 330, 0, 332, 0, 333, 334, 335, + 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, + 343, 0, 0, 344, 345, 346, 0, 348, 0, 350, + 351, 352, 353, 354, 355, 356, 0, 358, 359, 360, + 361, 0, 0, 0, 0, 362, 363, 364, 0, 366, + 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, + 376, 377, 0, 378, 379, 380, 0, 382, 383, 384, + 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, + 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, + 0, 404, 405, 406, 407, 0, 409, 410, 411, 412, + 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, + 421, 422, 423, 424, 425, 426, 427, 428, 429, 0, + 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, + 439, 440, 441, 442, 443, 444, 445, 446, 530, 448, + 449, 0, 0, 450, 451, 0, 452, 0, 454, 455, + 456, 457, 458, 0, 459, 460, 461, 0, 0, 462, + 463, 464, 465, 466, 0, 467, 468, 469, 470, 471, + 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, + 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, + 488, 0, 489, 0, 491, 492, 493, 494, 495, 496, + 497, 0, 0, 498, 0, 0, 499, 500, 501, 502, + 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, + 513, 514, 515, 516, 517, 518, 519, 1778, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, + 0, 1485, 0, 0, 0, 0, 1486, 130, 131, 0, + 132, 133, 134, 1487, 136, 137, 138, 0, 1488, 1489, + 1490, 1491, 0, 144, 145, 146, 147, 148, 149, 0, + 0, 150, 151, 152, 153, 1492, 1493, 156, 0, 157, + 158, 159, 160, 0, 0, 1494, 0, 1495, 164, 165, + 166, 167, 168, 1496, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 1497, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 1498, 191, 192, 1499, + 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, + 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, + 1063, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 0, 222, 223, 224, + 225, 226, 227, 0, 0, 229, 0, 230, 231, 1500, + 233, 0, 234, 0, 235, 1501, 0, 1502, 238, 239, + 0, 1503, 242, 0, 243, 0, 0, 0, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 1504, 256, + 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, + 266, 0, 267, 1505, 0, 270, 271, 272, 273, 274, + 1506, 1507, 0, 1508, 0, 278, 1509, 1510, 281, 1511, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 1512, + 291, 1513, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 0, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 1515, 1516, 1517, 325, 326, 327, 0, 0, + 329, 330, 1518, 332, 0, 0, 334, 1519, 336, 337, + 338, 0, 339, 340, 0, 0, 341, 342, 343, 0, + 0, 344, 345, 0, 1520, 348, 1521, 0, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, + 0, 0, 0, 362, 363, 0, 1522, 366, 367, 0, + 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, + 0, 378, 379, 380, 381, 382, 1523, 384, 385, 386, + 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 0, 401, 402, 1524, 404, + 405, 406, 0, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 0, 1526, 421, 422, + 423, 424, 425, 426, 0, 428, 429, 0, 1528, 431, + 432, 1529, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 0, 448, 0, 0, + 0, 450, 451, 0, 452, 1531, 454, 455, 456, 457, + 458, 0, 459, 1532, 1533, 0, 0, 462, 463, 0, + 465, 0, 0, 467, 468, 1534, 470, 471, 472, 473, + 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 0, 1536, 0, + 489, 1537, 491, 492, 493, 494, 495, 496, 497, 0, + 1, 498, 0, 0, 499, 500, 501, 502, 503, 504, + 2, 0, 3, 4, 0, 0, 0, 0, 1, 0, + 0, 516, 517, 518, 519, 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, 750, 0, + 0, 0, 10, 0, 0, 0, 0, 0, 0, 13, + 0, 0, 0, 0, 11, 0, 750, 0, 0, 0, + 0, 0, 0, 0, 14, 15, 0, 13, 0, 0, + 0, 0, 0, 0, 0, 751, 0, 0, 0, 0, + 0, 18, 14, 15, 0, 0, 0, 0, 0, 19, + 0, 0, 0, 751, 0, 0, 0, 0, 0, 18, + 0, 0, 0, 0, 0, 0, 22, 19, 0, 0, + 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 22, 0, 0, 0, 23, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, -1427, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -1427, 0, 0, 0, 0, 0, 0, 0, 25, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 25, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 26, 27, 28, 0, 0, 0, 0, + 0, 29, 0, 0, 30, 0, 0, 0, 0, 0, + 0, 26, 27, 28, 0, 0, 0, 0, 0, 29, + 0, 0, 30, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 31, 0, 0, 0, 0, + 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, + 0, 0, 0, 31, 0, 0, 0, 0, 0, 0, + 33, 0, 32, 0, 0, 0, 0, 34, 0, 0, + 0, 35, 0, 0, 0, 0, 0, 0, 33, 0, + 0, 36, 0, 0, 0, 34, 0, 0, 0, 35, + 0, 0, 0, 37, 0, 0, 0, 38, 0, 36, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 37, 0, 0, 0, 38, 0, 39, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 0, 39, 42, 0, 0, 0, + 0, 43, 0, 0, 0, 752, 0, 0, 40, 0, + 0, 0, 0, 0, 42, 0, 0, 44, 0, 43, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 44, 0, 0, 0, 0, + 0, 45, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 753, 0, 0, 0, 45, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 46 +}; + +static const yytype_int16 yycheck[] = +{ + 7, 0, 838, 46, 0, 520, 0, 0, 0, 16, + 0, 745, 899, 884, 0, 0, 23, 0, 0, 813, + 38, 910, 73, 0, 1231, 926, 995, 1429, 7, 1243, + 1701, 753, 861, 1229, 20, 20, 1582, 1162, 931, 1217, + 1204, 77, 986, 1036, 23, 986, 77, 2185, 20, 986, + 1663, 976, 986, 1083, 1285, 1206, 23, 1209, 2244, 2154, + 37, 2156, 1477, 1307, 17, 1556, 2175, 2331, 75, 76, + 1998, 1197, 1332, 965, 7, 1809, 0, 899, 976, 901, + 0, 903, 0, 1234, 1128, 0, 961, 2671, 0, 1133, + 23, 0, 0, 111, 0, 45, 75, 76, 2632, 1616, + 1617, 0, 0, 0, 2240, 2174, 2120, 2686, 75, 76, + 2632, 34, 0, 2669, 2504, 1004, 2292, 2293, 2294, 2693, + 75, 76, 1091, 809, 101, 746, 2311, 5, 814, 753, + 0, 0, 0, 752, 0, 0, 0, 0, 0, 0, + 0, 1667, 75, 76, 0, 0, 0, 2586, 1828, 1827, + 20, 2590, 5, 23, 1721, 984, 1831, 1999, 0, 5, + 1057, 1058, 5, 9, 1719, 5, 1939, 37, 777, 55, + 13, 14, 3005, 5, 5, 5, 46, 1074, 5, 80, + 2323, 13, 14, 5, 5, 5, 5, 45, 9, 5, + 5, 13, 14, 987, 13, 14, 2332, 13, 14, 5, + 5, 5, 9, 5, 5, 75, 76, 77, 45, 26, + 173, 2317, 5, 139, 1139, 13, 14, 74, 3, 119, + 5, 30, 13, 14, 74, 1972, 1973, 63, 23, 38, + 2319, 101, 124, 3, 4, 5, 1983, 4, 100, 9, + 1987, 2454, 9, 16, 3, 11, 2382, 2383, 122, 2385, + 16, 9, 191, 172, 976, 11, 1145, 147, 100, 1252, + 16, 1090, 2454, 107, 245, 181, 107, 117, 1261, 11, + 1171, 879, 2890, 15, 16, 34, 35, 856, 90, 879, + 75, 76, 288, 4, 122, 313, 172, 63, 9, 290, + 46, 806, 30, 1218, 11, 63, 1221, 1222, 15, 16, + 38, 11, 988, 313, 193, 15, 16, 291, 122, 3169, + 2960, 11, 169, 63, 1000, 15, 16, 129, 296, 1444, + 137, 2825, 119, 2827, 80, 30, 1061, 172, 218, 46, + 296, 117, 2844, 38, 382, 184, 46, 2990, 853, 213, + 276, 2436, 1077, 2548, 368, 2550, 3300, 117, 117, 1527, + 40, 82, 1477, 3332, 5, 3008, 1192, 1193, 82, 369, + 979, 245, 93, 80, 53, 193, 30, 1196, 132, 93, + 80, 40, 30, 2549, 41, 213, 1620, 30, 291, 107, + 120, 418, 391, 1037, 1037, 172, 2602, 162, 409, 11, + 266, 3408, 373, 164, 166, 148, 279, 3497, 11, 481, + 3099, 457, 3101, 433, 1560, 33, 296, 3357, 3358, 2143, + 290, 2945, 171, 1569, 173, 2601, 3000, 1318, 1289, 456, + 108, 503, 191, 3364, 46, 275, 250, 3011, 290, 479, + 280, 59, 85, 1014, 64, 517, 2574, 273, 3538, 1020, + 3394, 94, 122, 3397, 74, 321, 3002, 200, 290, 219, + 471, 275, 482, 503, 1347, 195, 245, 137, 80, 126, + 3410, 517, 2598, 238, 2600, 118, 3299, 80, 132, 358, + 451, 241, 329, 521, 132, 147, 3493, 294, 3457, 329, + 13, 14, 2496, 280, 512, 1139, 176, 2703, 177, 373, + 162, 340, 26, 517, 280, 167, 308, 347, 32, 361, + 484, 272, 512, 1533, 192, 194, 275, 176, 517, 3127, + 199, 517, 431, 396, 1758, 3456, 517, 3167, 454, 361, + 369, 285, 8, 3222, 360, 11, 3030, 355, 3146, 15, + 16, 2736, 373, 19, 20, 21, 517, 3491, 191, 2752, + 357, 457, 359, 521, 3197, 273, 218, 1156, 237, 475, + 36, 204, 324, 389, 517, 521, 2699, 447, 416, 459, + 2752, 538, 3395, 1217, 1217, 457, 238, 451, 1965, 1966, + 1967, 3431, 389, 2679, 2120, 419, 1991, 2713, 517, 416, + 454, 1096, 1813, 108, 360, 592, 1194, 506, 1752, 1168, + 399, 448, 360, 2682, 1194, 1492, 1493, 1331, 448, 2527, + 519, 3113, 1336, 137, 517, 3184, 1435, 457, 1342, 1869, + 360, 241, 424, 1449, 515, 287, 454, 479, 519, 2392, + 1517, 406, 407, 468, 296, 2192, 466, 1349, 481, 280, + 1466, 517, 75, 517, 167, 3169, 2191, 479, 2184, 517, + 454, 2158, 1849, 173, 431, 523, 2324, 3169, 328, 2329, + 503, 481, 2178, 1307, 1307, 104, 518, 1901, 520, 2334, + 520, 399, 451, 517, 517, 419, 520, 164, 538, 1913, + 1884, 517, 1665, 503, 517, 2861, 518, 517, 520, 3118, + 1577, 1578, 3072, 2868, 3123, 517, 517, 517, 515, 515, + 517, 523, 519, 519, 399, 517, 517, 517, 517, 1943, + 431, 517, 517, 2450, 1909, 394, 1950, 431, 467, 516, + 753, 517, 517, 517, 3298, 517, 517, 1338, 108, 517, + 1609, 1610, 1611, 2987, 517, 1349, 517, 3306, 517, 1348, + 1559, 1560, 181, 3307, 231, 1940, 222, 149, 508, 509, + 1569, 508, 509, 3396, 1988, 521, 753, 513, 1992, 506, + 508, 509, 405, 521, 1583, 408, 1442, 513, 479, 106, + 294, 804, 519, 0, 1499, 1996, 752, 752, 510, 511, + 512, 513, 517, 2842, 162, 447, 120, 2021, 132, 309, + 5, 753, 503, 1612, 1519, 162, 793, 508, 509, 201, + 167, 508, 509, 510, 511, 512, 513, 804, 457, 2727, + 510, 511, 512, 513, 518, 2981, 292, 521, 508, 509, + 510, 511, 512, 513, 793, 851, 275, 82, 1553, 592, + 851, 280, 3406, 357, 273, 804, 481, 1952, 93, 259, + 260, 838, 839, 884, 2848, 3391, 2895, 804, 856, 359, + 245, 1009, 82, 515, 2903, 520, 518, 519, 503, 804, + 238, 195, 2988, 93, 861, 389, 874, 1782, 517, 1027, + 793, 238, 517, 1031, 1857, 395, 1991, 1792, 467, 389, + 1795, 804, 871, 1527, 1527, 871, 2804, 871, 871, 871, + 339, 871, 752, 753, 2144, 871, 871, 859, 871, 871, + 1777, 4, 518, 3449, 871, 521, 9, 3431, 1632, 287, + 521, 908, 909, 481, 251, 912, 913, 132, 1423, 3431, + 287, 227, 862, 2647, 261, 2649, 1960, 840, 841, 2761, + 843, 275, 2764, 793, 2766, 503, 460, 214, 1750, 3193, + 37, 285, 178, 3517, 804, 160, 3258, 512, 3260, 1810, + 1811, 1812, 1835, 3129, 519, 203, 2071, 871, 378, 379, + 2496, 871, 275, 871, 178, 1777, 871, 273, 965, 871, + 1885, 174, 871, 871, 5, 871, 1620, 1620, 373, 976, + 341, 37, 871, 871, 871, 1797, 983, 984, 931, 428, + 1802, 851, 989, 871, 1876, 992, 993, 1885, 995, 996, + 997, 998, 1867, 979, 979, 241, 1871, 2514, 793, 1874, + 3109, 871, 871, 871, 1011, 871, 871, 871, 871, 804, + 871, 1018, 2414, 517, 3336, 871, 871, 241, 504, 505, + 506, 517, 508, 509, 510, 511, 512, 513, 1035, 1036, + 1037, 1892, 1011, 246, 2160, 1896, 2162, 108, 1899, 1018, + 2437, 2438, 2439, 2440, 1011, 355, 451, 178, 1091, 1056, + 275, 1018, 245, 162, 1788, 280, 1011, 203, 167, 1793, + 285, 2268, 506, 1018, 2295, 2556, 173, 515, 1075, 132, + 512, 519, 132, 517, 119, 380, 392, 519, 1011, 1086, + 1087, 1088, 2816, 1090, 1091, 1018, 2632, 3273, 1095, 2214, + 314, 380, 2336, 4, 345, 516, 3024, 160, 9, 172, + 160, 147, 209, 516, 1758, 1758, 527, 173, 245, 979, + 241, 252, 517, 345, 527, 373, 162, 1124, 225, 1948, + 515, 167, 517, 436, 519, 2276, 384, 373, 235, 238, + 469, 4, 345, 384, 1141, 1142, 9, 419, 454, 1175, + 1176, 1011, 1178, 209, 1175, 1176, 4, 1178, 1018, 373, + 1168, 9, 384, 515, 377, 518, 380, 519, 521, 225, + 1019, 419, 207, 1885, 1023, 826, 827, 828, 419, 235, + 1177, 384, 218, 380, 1181, 1182, 245, 423, 287, 425, + 373, 2150, 1052, 517, 1191, 1192, 1193, 419, 423, 1196, + 425, 2343, 238, 1434, 1064, 1436, 1437, 2349, 515, 423, + 517, 425, 189, 190, 2033, 451, 419, 423, 517, 425, + 1217, 469, 275, 438, 517, 1233, 1011, 280, 469, 167, + 280, 1091, 285, 1018, 449, 285, 2470, 451, 273, 174, + 275, 517, 840, 841, 13, 843, 373, 469, 71, 72, + 19, 287, 315, 316, 317, 1252, 518, 1901, 1901, 521, + 296, 30, 172, 479, 1261, 481, 469, 364, 451, 1913, + 1913, 518, 40, 517, 521, 44, 45, 423, 518, 425, + 517, 521, 259, 260, 518, 517, 383, 521, 1285, 2108, + 518, 517, 60, 521, 2155, 518, 13, 14, 521, 1943, + 1943, 423, 423, 425, 425, 517, 1950, 1950, 364, 517, + 1307, 246, 2848, 517, 373, 1175, 1176, 1306, 1178, 382, + 1306, 510, 1306, 1306, 451, 2730, 1323, 383, 518, 503, + 451, 521, 1095, 3509, 517, 1332, 518, 2452, 106, 521, + 109, 2456, 500, 518, 1988, 1988, 521, 517, 1992, 1992, + 8, 224, 1349, 11, 1998, 1998, 419, 15, 16, 519, + 227, 19, 20, 21, 518, 290, 3494, 521, 3496, 1366, + 13, 14, 1348, 1348, 1371, 26, 3461, 2021, 2021, 519, + 518, 32, 2247, 521, 2249, 438, 500, 1349, 438, 452, + 517, 3476, 451, 2219, 13, 14, 449, 26, 2632, 449, + 463, 378, 379, 32, 59, 518, 273, 171, 521, 3537, + 345, 447, 518, 518, 521, 521, 521, 6, 2615, 172, + 518, 10, 517, 521, 1421, 1422, 518, 26, 2614, 18, + 1427, 2322, 1429, 32, 202, 13, 14, 1434, 1435, 1436, + 1437, 518, 2646, 32, 521, 2599, 3531, 36, 2250, 384, + 2252, 3536, 1449, 1450, 517, 13, 14, 1454, 517, 1456, + 1429, 518, 1459, 518, 521, 295, 521, 1464, 59, 1466, + 1467, 2613, 1469, 2615, 341, 518, 1473, 2663, 521, 13, + 14, 2501, 2502, 251, 419, 1454, 137, 1456, 1348, 518, + 1459, 518, 521, 261, 521, 1464, 518, 1454, 1467, 1456, + 1469, 2598, 1459, 2600, 1473, 273, 1429, 1464, 137, 1454, + 1467, 1456, 1469, 518, 1459, 518, 1473, 172, 521, 1464, + 518, 517, 1467, 521, 1469, 392, 420, 3251, 1473, 3253, + 1527, 1454, 518, 1456, 469, 521, 1459, 305, 137, 518, + 500, 1464, 521, 2477, 1467, 2504, 1469, 2478, 2479, 2368, + 1473, 2478, 2479, 2480, 2478, 518, 518, 224, 521, 521, + 1323, 353, 1559, 1560, 222, 518, 518, 518, 521, 521, + 521, 1568, 1569, 152, 1556, 518, 1556, 152, 521, 1576, + 1556, 1556, 518, 1556, 1556, 521, 1583, 454, 152, 1556, + 518, 359, 152, 521, 1454, 876, 1456, 878, 152, 1459, + 13, 14, 40, 1366, 1464, 13, 14, 1467, 419, 1469, + 518, 1608, 517, 1473, 275, 1612, 384, 40, 1615, 13, + 14, 13, 14, 1620, 1621, 1622, 1623, 1624, 1625, 1626, + 1627, 1628, 1629, 3169, 292, 403, 1633, 1634, 2362, 13, + 14, 1638, 469, 294, 1429, 1642, 13, 14, 1645, 1646, + 1647, 1648, 1649, 1650, 1651, 1652, 1653, 2369, 3261, 1656, + 315, 316, 317, 13, 14, 294, 1663, 89, 1665, 1454, + 152, 1456, 13, 14, 1459, 13, 14, 2911, 1704, 1464, + 13, 14, 1467, 1704, 1469, 483, 2565, 1684, 1473, 13, + 14, 152, 2336, 2336, 519, 294, 1556, 13, 14, 13, + 14, 152, 353, 13, 14, 152, 357, 290, 2862, 355, + 1707, 431, 2909, 13, 14, 13, 14, 13, 14, 518, + 1682, 1718, 1719, 517, 353, 13, 14, 382, 357, 13, + 14, 368, 369, 517, 26, 368, 369, 993, 389, 517, + 32, 368, 369, 368, 369, 263, 264, 378, 379, 421, + 518, 462, 463, 220, 353, 3471, 3472, 517, 357, 225, + 389, 1758, 2588, 300, 419, 3503, 3504, 1141, 1142, 517, + 1767, 225, 1769, 2226, 2227, 1635, 8, 2945, 517, 11, + 225, 2985, 297, 15, 16, 40, 555, 19, 20, 21, + 389, 2674, 2653, 178, 236, 517, 5, 452, 3459, 5, + 325, 517, 3463, 517, 26, 2696, 5, 517, 463, 460, + 32, 517, 1809, 5, 517, 5, 1813, 8, 203, 1816, + 1817, 3213, 517, 5, 15, 16, 2470, 2470, 19, 20, + 21, 460, 9, 3067, 2817, 148, 993, 517, 517, 480, + 302, 2706, 104, 521, 1704, 137, 504, 505, 506, 518, + 508, 509, 510, 511, 512, 513, 241, 3518, 521, 40, + 1857, 460, 517, 220, 167, 389, 1629, 287, 167, 285, + 59, 236, 1869, 517, 431, 517, 93, 266, 431, 1876, + 1877, 521, 431, 2527, 2527, 59, 1853, 59, 1885, 431, + 108, 527, 222, 431, 479, 3431, 55, 380, 431, 152, + 100, 517, 275, 275, 1901, 199, 275, 40, 1905, 1906, + 295, 1908, 275, 275, 517, 137, 1913, 1914, 1915, 1916, + 1917, 1918, 1919, 152, 82, 1922, 1923, 1924, 1925, 1926, + 1927, 1928, 1929, 1930, 1931, 3169, 172, 519, 13, 172, + 1937, 1938, 518, 102, 1941, 518, 1943, 518, 518, 518, + 108, 1948, 518, 1950, 521, 518, 517, 476, 225, 225, + 282, 282, 517, 519, 123, 517, 466, 199, 39, 517, + 521, 517, 3364, 1970, 517, 519, 517, 1974, 747, 1976, + 475, 1841, 141, 1980, 9, 2900, 145, 517, 2632, 2632, + 222, 1988, 429, 1853, 3180, 1992, 517, 1994, 429, 1996, + 11, 1998, 294, 355, 1767, 1974, 1769, 516, 521, 168, + 527, 1980, 171, 521, 524, 3407, 174, 1974, 429, 517, + 280, 517, 431, 1980, 2021, 1182, 181, 163, 187, 1974, + 172, 521, 518, 2757, 1191, 1980, 2033, 2034, 423, 457, + 425, 521, 218, 266, 392, 203, 291, 2912, 2913, 227, + 313, 1974, 313, 521, 68, 69, 521, 1980, 181, 220, + 292, 353, 518, 448, 3456, 357, 451, 517, 26, 296, + 227, 275, 294, 227, 32, 2108, 2073, 334, 288, 469, + 3039, 2078, 2079, 2727, 2727, 517, 152, 3, 246, 517, + 517, 3295, 152, 862, 152, 109, 110, 389, 152, 113, + 114, 292, 479, 152, 40, 275, 2103, 2104, 3, 40, + 290, 2108, 59, 172, 1974, 290, 40, 11, 518, 167, + 1980, 280, 3237, 518, 517, 2122, 181, 518, 2125, 288, + 2127, 353, 518, 517, 517, 357, 167, 3, 39, 3, + 515, 431, 431, 521, 515, 431, 2143, 2144, 431, 500, + 518, 310, 516, 2150, 524, 500, 2153, 2881, 518, 518, + 2804, 2804, 172, 519, 518, 1421, 1422, 389, 460, 518, + 517, 1427, 518, 2170, 518, 189, 190, 500, 518, 137, + 339, 518, 431, 517, 2153, 517, 2183, 155, 517, 1974, + 517, 476, 40, 250, 59, 1980, 2153, 3431, 506, 291, + 502, 2170, 521, 2200, 2201, 291, 454, 244, 59, 521, + 59, 431, 468, 2170, 266, 373, 517, 152, 203, 275, + 2217, 8, 2219, 152, 11, 152, 384, 518, 15, 16, + 2153, 282, 19, 20, 21, 2232, 431, 3434, 460, 253, + 254, 255, 256, 257, 258, 259, 260, 2170, 2108, 263, + 264, 40, 431, 2250, 2251, 2252, 3147, 355, 431, 282, + 431, 419, 521, 517, 1421, 1422, 2126, 2911, 2911, 288, + 1427, 517, 504, 505, 506, 518, 508, 509, 510, 511, + 512, 513, 2142, 290, 442, 479, 40, 280, 518, 152, + 172, 517, 2289, 2153, 2327, 186, 517, 59, 2295, 518, + 167, 2945, 2945, 518, 518, 80, 518, 515, 3020, 143, + 2170, 469, 199, 504, 505, 506, 518, 508, 509, 510, + 511, 512, 513, 337, 338, 7, 8, 2316, 172, 517, + 2316, 13, 2316, 2316, 2331, 518, 294, 19, 301, 2336, + 527, 23, 291, 25, 361, 181, 152, 29, 30, 31, + 518, 518, 34, 517, 176, 37, 38, 2354, 521, 41, + 442, 517, 44, 45, 378, 379, 518, 518, 2153, 518, + 517, 2368, 2369, 521, 518, 518, 40, 518, 517, 2376, + 3024, 3024, 519, 517, 3263, 2170, 518, 151, 517, 40, + 521, 86, 1161, 75, 76, 353, 457, 521, 172, 357, + 517, 478, 518, 518, 3223, 199, 3225, 518, 172, 3235, + 516, 516, 199, 521, 518, 518, 518, 2414, 518, 101, + 463, 290, 506, 3067, 3067, 59, 108, 109, 110, 111, + 112, 389, 479, 518, 205, 222, 117, 518, 518, 518, + 40, 517, 227, 88, 192, 2414, 519, 280, 280, 519, + 519, 519, 519, 431, 3238, 519, 3240, 2454, 431, 473, + 474, 506, 40, 3422, 275, 107, 519, 2327, 40, 519, + 516, 2504, 516, 2470, 2482, 3366, 290, 519, 519, 519, + 519, 5, 518, 497, 498, 519, 519, 2250, 2251, 2252, + 2487, 2414, 519, 519, 518, 3356, 2493, 2494, 3375, 519, + 518, 2542, 460, 517, 2537, 292, 519, 2504, 479, 9, + 519, 519, 354, 519, 519, 519, 519, 519, 2515, 519, + 519, 2518, 519, 2520, 3350, 3169, 3169, 519, 519, 519, + 2527, 2528, 521, 517, 2531, 2532, 517, 517, 517, 2536, + 2537, 517, 59, 336, 521, 199, 2543, 521, 518, 518, + 1707, 315, 316, 317, 516, 2588, 192, 462, 91, 518, + 517, 2558, 40, 347, 152, 519, 518, 124, 2331, 152, + 1339, 2568, 1341, 40, 2556, 518, 2556, 369, 369, 518, + 2556, 2556, 40, 2556, 2556, 517, 40, 517, 521, 2556, + 310, 2588, 517, 280, 517, 2562, 457, 249, 8, 191, + 457, 11, 126, 127, 442, 15, 16, 517, 74, 19, + 20, 21, 74, 2376, 293, 80, 9, 517, 382, 518, + 518, 371, 518, 516, 516, 59, 36, 133, 506, 2414, + 93, 290, 2629, 273, 442, 2632, 2633, 40, 2635, 518, + 517, 517, 462, 293, 2504, 293, 518, 518, 172, 205, + 2647, 290, 2649, 290, 389, 419, 518, 454, 1914, 1915, + 1916, 1917, 1918, 1919, 368, 122, 1922, 1923, 1924, 1925, + 1926, 1927, 1928, 1929, 1930, 1931, 148, 2537, 25, 36, + 3404, 298, 368, 2616, 2673, 871, 1775, 2673, 452, 2673, + 2673, 2629, 2245, 3265, 2566, 3360, 2556, 8, 3407, 463, + 11, 3508, 2562, 2670, 15, 16, 2905, 1876, 19, 20, + 21, 2357, 3381, 848, 3486, 479, 2749, 504, 505, 506, + 3140, 508, 509, 510, 511, 512, 513, 2724, 2588, 3435, + 2727, 2698, 3479, 1037, 2701, 25, 3444, 3199, 2238, 503, + 1204, 2687, 2251, 3433, 3442, 2608, 2235, 2744, 2745, 2635, + 3430, 1331, 2749, 517, 1304, 2752, 2315, 1914, 1915, 1916, + 1917, 1918, 1919, 2376, 3020, 1922, 1923, 1924, 1925, 1926, + 1927, 1928, 1929, 1930, 1931, 2217, 1010, 2183, 1743, 1161, + 147, 2665, 2779, 1185, 3416, 1010, 1184, 3431, 3431, 1707, + 2200, 315, 316, 317, 3338, 162, 2793, 1037, 2435, 3227, + 167, 2798, 2799, 1742, 23, 2838, 2803, 2804, 1187, 1986, + 2670, 2808, 222, 2170, 2811, 2812, 2752, 3062, 804, 2816, + 2817, 793, 988, 2820, 3329, 115, 2414, 2824, 2413, 13, + 2462, 3161, 3342, 2001, 2831, 19, 986, 1885, 2698, 1885, + 37, 2701, 3341, 2184, 172, 42, 30, 2103, 2104, 2080, + 2494, 218, 2126, 2123, 2035, 2824, 986, 539, 382, 986, + 44, 45, 544, 1450, 986, 547, 2629, 2824, 986, 393, + 2633, 238, 2635, 555, 986, 2082, 986, 986, 2875, 2824, + 2831, 2511, 292, 2556, 3327, 986, 2883, 1819, 889, 2749, + 1349, 415, 1994, 1682, 2288, 419, 2567, 1683, 788, 1241, + 101, 2824, -1, -1, 101, 2902, -1, -1, -1, -1, + -1, 222, -1, 1217, 2911, 74, -1, -1, -1, 8, + 287, 80, 11, -1, -1, 109, 15, 16, 452, 296, + 19, 20, 21, -1, 93, -1, -1, -1, -1, 463, + -1, -1, -1, -1, -1, -1, 2103, 2104, 2945, -1, + -1, -1, 40, -1, -1, 479, -1, -1, 117, -1, + 119, -1, -1, -1, 2824, -1, 117, -1, -1, -1, + -1, -1, 60, -1, -1, -1, 173, 1217, 2838, 503, + -1, 292, -1, -1, 1753, -1, -1, 315, 316, 317, + 2987, -1, -1, 517, 1763, 2992, 1765, -1, -1, 1768, + -1, -1, -1, 1307, -1, 1774, 3039, 1776, -1, -1, + -1, -1, 209, -1, -1, -1, -1, -1, 106, -1, + 1789, 172, -1, 3020, -1, 1794, 3023, 3024, 225, 1798, + 1799, 1800, 1801, -1, 1803, 1804, 3003, -1, 235, 2824, + -1, -1, 3039, -1, -1, -1, -1, -1, 207, -1, + -1, -1, -1, -1, 382, -1, -1, -1, -1, -1, + 2217, -1, -1, 745, 746, 747, -1, 1307, -1, -1, + 3067, -1, 269, -1, -1, 3072, -1, -1, -1, -1, + 447, -1, -1, -1, -1, -1, 3083, 3084, 176, -1, + 3087, 419, 3089, 290, 504, 505, 506, -1, 508, 509, + 510, 511, 512, 513, -1, 787, 788, -1, -1, -1, + -1, 793, -1, 795, 202, -1, 275, 3114, 315, -1, + -1, 280, 804, -1, 452, 322, 808, 809, -1, -1, + -1, 813, 814, -1, -1, 463, -1, -1, -1, -1, + -1, 3138, -1, 3003, 826, 827, 828, -1, 515, -1, + -1, 479, 519, 304, -1, -1, -1, -1, 840, 841, + -1, 843, -1, 251, 315, 316, 317, 364, -1, -1, + 329, -1, 3169, 261, 856, 503, -1, -1, -1, 3039, + 862, -1, -1, -1, -1, 273, 383, -1, 347, 517, + -1, -1, 874, 504, 505, 506, 3193, 508, 509, 510, + 511, 512, 513, 292, -1, -1, 888, 889, -1, -1, + -1, -1, 3209, -1, -1, -1, 3213, 305, -1, 3186, + 3187, -1, -1, 1527, 2987, -1, 3223, -1, 3225, -1, + 3227, 382, -1, -1, 3231, -1, 3233, -1, 3235, -1, + -1, 923, 924, -1, 3213, -1, -1, -1, -1, 3246, + -1, -1, -1, 935, 3251, 452, 3253, 939, 940, 941, + 942, -1, -1, -1, 3261, -1, -1, -1, 419, -1, + -1, 359, -1, 955, -1, 2531, 2532, 3274, -1, -1, + -1, -1, 3279, -1, 993, -1, -1, 1527, -1, 448, + 3213, -1, -1, -1, -1, 3262, 384, 3264, 457, -1, + -1, 452, -1, -1, 37, 987, 988, -1, 990, 42, + -1, 993, 463, -1, -1, 403, 1620, 999, 1000, -1, + -1, -1, -1, 1005, -1, -1, 3186, 3187, 479, 1011, + -1, 3328, 8, -1, -1, 11, 1018, -1, 3305, 15, + 16, 3338, -1, 19, 20, 21, 1028, -1, -1, -1, + -1, -1, 503, 3350, 3321, -1, -1, -1, 3325, -1, + 36, -1, 1044, -1, -1, -1, 517, 3364, 101, -1, + -1, 555, -1, -1, 2531, 2532, -1, -1, -1, -1, + 1620, 8, -1, -1, 11, 3382, -1, -1, 15, 16, + -1, -1, 19, 20, 21, 3364, 2165, -1, -1, -1, + -1, -1, 3262, -1, 3264, -1, -1, -1, -1, 36, + 3407, 1093, 126, 127, -1, 504, 505, 506, -1, 508, + 509, 510, 511, 512, 513, 3422, -1, -1, 3213, -1, + 3193, -1, -1, -1, 3431, -1, 3433, -1, 3407, -1, + 173, 3364, -1, -1, -1, 3305, -1, -1, 181, -1, + -1, -1, 178, -1, 1758, -1, -1, -1, 172, 3456, + -1, 3321, 1144, -1, 1146, 3325, -1, -1, 2724, -1, + -1, -1, -1, 3470, 3471, 3472, 209, 203, -1, 1161, + 1162, 3448, 1191, -1, 3407, -1, 1168, 3456, -1, -1, + -1, -1, 225, -1, -1, -1, -1, 787, -1, -1, + 3497, -1, 235, -1, -1, -1, -1, 3474, -1, 1191, + -1, 3274, -1, -1, -1, 241, -1, -1, 1758, -1, + -1, 1203, 1204, -1, -1, -1, -1, -1, 818, -1, + -1, -1, -1, 3456, 1216, -1, 269, -1, -1, -1, + -1, 3538, -1, -1, -1, -1, 222, -1, -1, -1, + -1, 1233, 842, -1, -1, 1237, -1, 290, -1, -1, + 1242, -1, 746, 747, -1, -1, -1, 2724, -1, 295, + -1, -1, -1, -1, -1, -1, 1037, 2346, -1, 3364, + -1, -1, 315, -1, -1, -1, -1, -1, 3448, 322, + -1, -1, 2749, -1, -1, 222, -1, 1901, -1, 889, + -1, 315, 316, 317, -1, -1, -1, -1, -1, 1913, + -1, -1, -1, -1, 3474, -1, 292, -1, 1300, -1, + 1302, -1, 3407, -1, -1, -1, -1, 2883, -1, 1311, + -1, 364, 40, -1, -1, -1, 2793, -1, -1, 1943, + 1322, -1, -1, -1, -1, -1, 1950, 373, -1, 1331, + 383, -1, 60, -1, 1336, -1, 1338, 1339, -1, 1341, + 1342, 1901, -1, -1, -1, 292, -1, -1, 382, -1, + 3433, 3456, -1, 1913, -1, -1, -1, -1, 862, 393, + -1, -1, -1, -1, 1988, -1, 976, -1, 1992, -1, + -1, -1, -1, -1, 1998, -1, 986, 423, 106, 425, + -1, 415, -1, 1943, -1, 419, -1, -1, -1, -1, + 1950, -1, 1421, 1422, -1, 37, 442, 2021, 1427, 452, + 42, -1, 448, -1, 457, 451, 2883, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 452, 1421, + 1422, -1, -1, -1, -1, 1427, -1, 1429, 1988, 463, + -1, -1, 1992, -1, -1, -1, 1217, -1, 1998, -1, + 1442, 976, 1444, 1445, -1, 479, -1, 3023, -1, -1, + 1452, -1, 1454, -1, 1456, -1, -1, 1459, -1, 101, + -1, 2021, 1464, -1, -1, 1467, -1, 1469, -1, 503, + -1, 1473, -1, 1475, 202, 1477, -1, -1, -1, -1, + -1, -1, -1, 517, -1, -1, -1, -1, -1, -1, + 1100, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 1110, 1005, 2591, -1, -1, 2594, -1, -1, 504, 505, + 506, -1, 508, 509, 510, 511, 512, 513, -1, 41, + 1130, -1, -1, 251, 1028, -1, 1307, -1, -1, 1139, + -1, 173, 2621, 261, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 273, 3023, 2636, 2637, 2638, + 2639, 2640, 2641, 2642, 2643, 2644, 2645, 504, 505, 506, + -1, 508, 509, 510, 511, 512, 513, 209, -1, -1, + -1, 0, -1, -1, -1, 1110, -1, 305, -1, -1, + 1582, -1, -1, 225, -1, -1, 108, 1037, 110, 1093, + 112, 1593, -1, 235, -1, -1, -1, -1, -1, -1, + -1, -1, 1037, -1, 1139, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 517, -1, -1, 22, 23, - 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, - -1, -1, -1, -1, -1, -1, -1, -1, 42, 43, - 44, -1, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, -1, 59, 60, 61, 62, 63, - 64, -1, 66, 67, 68, 69, 70, 71, 72, 73, - -1, 75, 76, 77, 78, 79, -1, 81, -1, 83, - 84, 85, 86, 87, 88, 89, 90, 91, 92, -1, - 94, 95, 96, 97, 98, 99, -1, 101, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, - 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, - 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, - 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, -1, 161, -1, 163, - 164, 165, 166, -1, 168, -1, 170, 171, -1, 173, - 174, 175, 176, 177, 178, -1, 180, -1, 182, 183, - 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, - 194, 195, 196, 197, 198, -1, 200, 201, 202, 203, - 204, 205, 206, -1, 208, 209, 210, 211, 212, 213, - 214, 215, 216, 217, -1, 219, -1, 221, 222, 223, - 224, 225, 226, 227, 228, 229, 230, 231, -1, -1, - 234, 235, 236, 237, -1, 239, 240, 241, 242, 243, - 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, - 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, - 274, -1, 276, 277, 278, 279, -1, 281, 282, 283, - 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, - 294, -1, -1, 297, 298, 299, 300, 301, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, -1, -1, -1, -1, 319, 320, 321, 322, 323, - 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, - 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, - 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, - 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, - 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, - 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, - 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, -1, -1, 417, 418, -1, 420, 421, 422, 423, - 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, - 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, - 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, - 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, - 464, -1, 466, 467, 468, 469, 470, 471, 472, 473, - 474, -1, -1, 477, -1, -1, 480, 481, 482, 483, - 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, - 494, 495, 496, 497, 498, 499, 500, 3, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 269, -1, -1, + 1632, 359, 1661, -1, -1, -1, -1, -1, -1, -1, + 151, -1, -1, -1, -1, -1, -1, -1, 290, -1, + -1, -1, 8, -1, -1, 11, 384, 1161, 1162, 15, + 16, 172, -1, 19, 20, 21, -1, -1, -1, -1, + -1, 100, -1, 315, -1, 403, -1, 1679, 1707, 1681, + 322, 1683, -1, 1218, -1, -1, 1221, 1222, -1, -1, + 46, 1693, -1, 1695, -1, -1, -1, 53, -1, -1, + -1, -1, -1, -1, -1, 1707, -1, -1, -1, -1, + -1, -1, 2336, -1, -1, -1, -1, -1, 147, -1, + -1, -1, 364, -1, 80, -1, -1, -1, -1, -1, + 1732, -1, 1734, 162, -1, -1, -1, -1, 167, -1, + -1, 383, -1, 172, 1746, 1747, 1527, -1, -1, -1, + 1752, 1753, 181, -1, -1, 1365, 3233, 186, -1, -1, + -1, 1763, 1764, 1765, 1766, -1, 1768, 1217, -1, -1, + -1, -1, 1774, -1, 1776, -1, 2336, -1, -1, -1, + -1, -1, 1217, -1, -1, -1, 1788, 1789, -1, 218, + -1, 1793, 1794, 2882, -1, -1, 1798, 1799, 1800, 1801, + -1, 1803, 1804, -1, 315, 316, 317, -1, -1, 238, + 452, -1, -1, -1, -1, 457, -1, -1, 1820, 1354, + 1355, 177, -1, -1, -1, -1, 1828, -1, 1830, 1831, + 1832, 1833, 1834, -1, 1338, 1339, -1, 1341, 194, 1620, + -1, -1, -1, 199, -1, -1, 2470, -1, -1, 1851, + -1, 172, -1, -1, -1, -1, -1, 1307, 287, -1, + -1, 290, 1864, -1, -1, -1, -1, 296, -1, -1, + -1, 382, 1307, -1, -1, -1, -1, -1, -1, -1, + -1, 237, -1, -1, -1, 1914, 1915, 1916, 1917, 1918, + 1919, -1, -1, 1922, 1923, 1924, 1925, 1926, 1927, 1928, + 1929, 1930, 1931, 2527, -1, -1, -1, 336, 419, -1, + 2470, -1, 1914, 1915, 1916, 1917, 1918, 1919, -1, -1, + 1922, 1923, 1924, 1925, 1926, 1927, 1928, 1929, 1930, 1931, + -1, -1, 361, -1, -1, -1, 292, -1, -1, -1, + 1444, 452, -1, -1, -1, -1, -1, -1, -1, -1, + 1952, -1, 463, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 1964, -1, -1, -1, -1, 2527, 479, -1, + -1, 1475, 1974, 1477, -1, -1, -1, 1758, 1980, -1, + -1, -1, -1, 304, 1986, -1, -1, -1, -1, 1991, + 419, -1, 503, -1, 315, 316, 317, -1, 2000, 2001, + -1, -1, -1, -1, -1, -1, 517, -1, 2632, -1, + -1, -1, -1, -1, -1, -1, -1, 539, 447, -1, + -1, -1, 544, -1, -1, 547, -1, -1, 457, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 394, 1574, + -1, -1, -1, -1, -1, -1, -1, 476, -1, 478, + 479, 1586, -1, 1588, -1, -1, -1, 37, -1, -1, + 3149, 382, 42, 1673, -1, -1, -1, -1, -1, 2071, + -1, -1, 2632, 2075, 2103, 2104, -1, 1527, 2080, 1614, + -1, 3170, 3171, -1, -1, -1, 515, -1, -1, 518, + 519, 520, 1527, -1, -1, -1, -1, -1, 419, -1, + -1, 2103, 2104, 2727, -1, -1, -1, 3196, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 2120, -1, + 1901, 101, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 452, 1913, -1, -1, -1, 1746, 1747, -1, -1, + -1, 178, 463, -1, -1, 501, -1, -1, 504, 505, + 506, 2153, 508, 509, 510, 511, 512, 513, 479, -1, + -1, -1, 1943, 2165, -1, -1, 203, 2727, 2170, 1950, + 1620, -1, 2174, -1, -1, -1, -1, -1, -1, -1, + 2804, -1, 503, 1718, 1719, 1620, -1, -1, 2217, -1, + -1, -1, -1, 173, -1, 1805, 517, -1, -1, -1, + -1, -1, -1, -1, 241, -1, -1, 1988, 1818, 1819, + -1, 1992, 2214, -1, -1, 2217, -1, 1998, 2220, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 209, + 1734, -1, -1, -1, -1, -1, -1, -1, 2240, -1, + 2021, -1, -1, -1, 2804, 225, -1, 1782, -1, 1753, + -1, -1, -1, -1, -1, 235, -1, 1792, 295, 1763, + 1795, 1765, 40, -1, 1768, -1, -1, -1, -1, -1, + 1774, -1, 1776, 795, -1, 1885, -1, 314, -1, -1, + -1, 1891, 60, -1, -1, 1789, -1, 2911, -1, 269, + 1794, -1, -1, -1, 1798, 1799, 1800, 1801, -1, 1803, + 1804, -1, -1, -1, -1, -1, -1, -1, 1758, 2311, + -1, -1, -1, -1, -1, -1, 2318, -1, -1, -1, + -1, 2945, -1, 1758, -1, -1, -1, 2329, 106, 107, + 2332, 2333, 2334, 2335, -1, 315, 373, -1, 3427, 117, + -1, -1, 322, 380, 2346, -1, 2348, -1, -1, 2351, + 1885, 2911, -1, -1, 2356, -1, -1, -1, -1, -1, + 2362, -1, -1, -1, -1, -1, 888, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 517, -1, -1, 22, 23, 24, 25, - 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, - 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, - 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, - -1, 67, 68, 69, 70, 71, 72, 73, -1, 75, - 76, 77, 78, 79, -1, -1, -1, 83, 84, 85, - 86, 87, 88, -1, 90, 91, 92, -1, 94, 95, - 96, 97, 98, 99, -1, -1, 102, 103, 104, 105, - 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, - 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, - 126, 127, 128, 129, 130, 131, -1, -1, 134, 135, - 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, - 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, -1, 161, -1, 163, 164, 165, - 166, -1, 168, -1, 170, -1, 172, -1, 174, 175, - 176, -1, 178, -1, 180, -1, 182, 183, 184, 185, - -1, 187, 188, 189, 190, 191, 192, 193, -1, 195, - 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, - 206, -1, 208, -1, 210, 211, 212, 213, 214, 215, - 216, 217, -1, 219, -1, 221, -1, -1, 224, -1, - 226, 227, 228, 229, 230, 231, -1, -1, 234, -1, - 236, -1, -1, 239, 240, 241, 242, 243, 244, 245, - 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, - 266, 267, 268, -1, 270, 271, 272, 273, 274, -1, - 276, 277, -1, 279, -1, 281, 282, 283, 284, 285, - 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, - -1, 297, 298, 299, -1, 301, -1, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, -1, 319, 320, 321, -1, 323, 324, 325, - 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, - -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, - 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, -1, 362, 363, -1, 365, - 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, - 376, 377, 378, 379, 380, 381, 382, -1, 384, 385, - 386, 387, 388, 389, 390, 391, 392, 393, -1, 395, - 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - -1, 417, 418, 419, 420, -1, 422, 423, 424, 425, - 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, - 436, 437, -1, 439, 440, 441, 442, 443, 444, 445, - 446, -1, -1, 449, 450, 451, 452, 453, 454, 455, - 456, -1, 458, 459, 460, 461, 462, 463, 464, -1, - 466, -1, 468, 469, 470, 471, 472, 473, 474, -1, - -1, 477, -1, 479, 480, 481, 482, 483, 484, 485, - 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, - 496, 497, 498, 499, 500, 3, -1, 503, -1, -1, + 2382, 2383, -1, 2385, 364, 2945, 423, -1, 425, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 176, -1, + 3024, 923, -1, 383, -1, 442, -1, -1, -1, -1, + -1, 448, 2414, -1, 451, -1, -1, 939, 940, 941, + 942, -1, -1, -1, 202, 26, -1, -1, -1, -1, + -1, 32, 2434, -1, -1, -1, -1, -1, -1, 40, + 2442, 2443, 2444, 3067, -1, -1, -1, -1, 1952, -1, + 2452, 1901, 2454, -1, 2456, -1, -1, -1, -1, 60, + 2462, -1, -1, 1913, 3024, -1, 1901, -1, 990, -1, + 2005, -1, 452, 251, -1, -1, -1, -1, 1913, -1, + 2482, -1, 1986, 261, -1, -1, -1, 1991, -1, -1, + -1, -1, -1, 1943, 2496, 273, -1, 275, -1, -1, + 1950, -1, 2531, 2532, -1, 106, -1, 3067, 1943, -1, + -1, -1, -1, -1, -1, 1950, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 305, -1, 2531, + 2532, -1, -1, -1, -1, -1, 137, -1, 1988, -1, + -1, -1, 1992, -1, -1, 3169, -1, -1, 1998, -1, + -1, -1, -1, 1988, -1, 2336, -1, 1992, 2560, -1, + -1, -1, -1, 1998, 2566, -1, -1, 2071, -1, -1, + -1, 2021, -1, -1, -1, -1, 2080, -1, -1, -1, + 2582, 359, -1, -1, 2586, -1, 2021, -1, 2590, 2591, + -1, -1, 2594, -1, -1, -1, 2598, 2599, 2600, -1, + 2602, 202, -1, -1, -1, -1, 384, -1, -1, 3169, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 2621, + -1, 2623, 2157, -1, -1, 403, -1, 405, -1, -1, + 408, 0, -1, -1, 2636, 2637, 2638, 2639, 2640, 2641, + 2642, 2643, 2644, 2645, -1, -1, -1, 2257, -1, -1, + 251, -1, -1, -1, -1, 2190, 2191, -1, -1, -1, + 261, 2165, -1, -1, -1, -1, -1, 2669, -1, -1, + -1, -1, 273, 2675, -1, -1, -1, -1, -1, -1, + -1, 1203, -1, -1, -1, 2687, -1, -1, -1, 2470, + -1, -1, -1, 294, 1216, 2724, -1, -1, -1, 2309, + -1, 2703, -1, -1, 305, -1, -1, -1, -1, -1, + 2214, 2713, -1, -1, -1, 1237, 2220, 2327, -1, -1, + 2749, -1, 2724, -1, -1, -1, -1, -1, 2730, -1, + -1, 100, -1, -1, -1, 2737, 2738, 2739, 2740, 517, + -1, -1, -1, -1, -1, -1, 2527, 2749, -1, -1, + 2752, -1, 353, -1, 2756, 2757, 357, -1, 359, 2369, + -1, -1, -1, 2765, -1, -1, -1, -1, 2378, -1, + 2380, -1, -1, -1, 2384, -1, 2386, -1, 147, -1, + 1302, -1, -1, 384, -1, -1, -1, -1, 389, 1311, + 2792, -1, -1, 162, -1, -1, -1, -1, 167, -1, + -1, -1, 403, 172, -1, -1, -1, 3431, -1, -1, + -1, -1, 181, -1, -1, -1, -1, 186, -1, -1, + 2822, -1, 2824, -1, -1, -1, -1, 8, -1, -1, + 11, -1, -1, -1, 15, 16, 2838, -1, -1, -1, + 2842, -1, 2346, -1, -1, -1, 2848, -1, -1, 218, + -1, 2632, -1, -1, 2883, -1, -1, -1, -1, 460, + 2862, -1, -1, -1, -1, 46, 2868, -1, -1, 238, + -1, 3431, 53, -1, -1, -1, -1, -1, -1, 2881, + 2882, 2883, -1, -1, -1, -1, 2336, 2889, -1, -1, + 8, -1, -1, 11, -1, -1, -1, 15, 16, 80, + -1, 2336, -1, -1, 2906, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 287, -1, + -1, 290, -1, -1, -1, -1, -1, 296, 46, -1, + 1452, -1, -1, -1, -1, 53, -1, -1, -1, 2474, + 2475, -1, -1, -1, -1, -1, 2727, -1, 2452, -1, + -1, -1, 2456, -1, -1, -1, -1, -1, 2462, -1, + -1, -1, 80, -1, 145, -1, -1, 336, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 517, -1, -1, 22, 23, 24, 25, 26, 27, - 28, 29, 30, 31, 32, 33, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 43, 44, -1, 46, 47, - 48, -1, 50, 51, 52, 53, 54, -1, 56, 57, - -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, - 68, 69, 70, 71, 72, 73, -1, 75, 76, 77, - 78, 79, -1, -1, -1, 83, 84, 85, 86, 87, - 88, -1, 90, 91, 92, -1, 94, 95, 96, 97, - 98, 99, -1, -1, 102, 103, 104, 105, 106, 107, - 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, - 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, - 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, - 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, - 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, -1, 161, -1, 163, 164, 165, 166, -1, - 168, -1, 170, -1, 172, -1, 174, 175, 176, -1, - 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, - 188, 189, 190, 191, 192, 193, -1, 195, 196, 197, - 198, -1, 200, 201, 202, 203, 204, 205, 206, -1, - 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, - -1, 219, -1, 221, -1, -1, 224, -1, 226, 227, - 228, 229, 230, 231, -1, -1, 234, -1, 236, -1, - -1, 239, 240, 241, 242, 243, 244, 245, 246, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, -1, 270, 271, 272, 273, 274, -1, 276, 277, - -1, 279, -1, 281, 282, 283, 284, 285, 286, -1, - 288, 289, -1, -1, 292, 293, 294, -1, -1, 297, - 298, 299, -1, 301, -1, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - -1, 319, 320, 321, -1, 323, 324, 325, 326, 327, - 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, - 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, -1, 362, 363, -1, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, 379, 380, 381, 382, -1, 384, 385, 386, 387, - 388, 389, 390, 391, 392, -1, -1, 395, 396, 397, - 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, 412, 413, 414, -1, -1, 417, - 418, 419, 420, -1, 422, 423, 424, 425, 426, -1, - 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, - -1, 439, 440, 441, 442, 443, 444, 445, 446, -1, - -1, 449, 450, 451, 452, 453, 454, 455, 456, -1, - 458, 459, 460, 461, 462, 463, 464, -1, 466, -1, - 468, 469, 470, 471, 472, 473, 474, -1, -1, 477, - -1, 479, 480, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 498, 499, 500, 3, -1, 503, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 517, - -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, + -1, -1, 2984, -1, -1, -1, 2988, -1, -1, -1, + -1, -1, 361, -1, 3023, -1, 177, -1, -1, -1, + 3002, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 194, 3016, -1, -1, -1, 199, -1, + 2470, 3023, 2632, 2804, -1, -1, -1, 145, -1, -1, + -1, -1, -1, -1, -1, 2470, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 3049, -1, -1, + 419, -1, -1, 3055, -1, 2665, 237, -1, -1, 177, + 3062, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 194, 2527, 447, -1, + -1, 199, 2586, -1, -1, -1, 2590, 2591, 457, -1, + 2594, -1, 2527, -1, 3096, -1, -1, 2632, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 476, -1, 478, + 479, 292, -1, -1, -1, -1, 3118, 2621, -1, 237, + -1, 3123, -1, -1, -1, -1, -1, -1, -1, -1, + 2911, -1, 2636, 2637, 2638, 2639, 2640, 2641, 2642, 2643, + 2644, 2645, -1, -1, -1, -1, 515, 3149, -1, 518, + 519, 520, -1, -1, -1, -1, -1, -1, -1, 1681, + -1, 1683, -1, -1, 2945, -1, -1, -1, 3170, 3171, + -1, 1693, -1, -1, 292, -1, -1, -1, -1, -1, + -1, -1, 2632, -1, -1, -1, -1, 3189, -1, 3191, + -1, -1, -1, -1, 3196, -1, -1, 2632, -1, -1, + -1, -1, -1, -1, 3233, -1, -1, -1, 3210, -1, + 1732, 3213, -1, 394, -1, -1, -1, -1, 2828, -1, + -1, -1, -1, -1, -1, -1, 2730, 2762, -1, -1, + -1, 3233, -1, -1, -1, 3237, 3238, -1, 3240, -1, + -1, -1, -1, 3024, -1, -1, -1, -1, -1, -1, + -1, -1, 2756, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 3265, -1, -1, -1, -1, -1, -1, + 3272, -1, -1, -1, -1, -1, 394, 2727, -1, -1, + -1, 838, 839, -1, -1, -1, 3067, -1, -1, -1, + -1, -1, 2727, -1, -1, -1, -1, -1, -1, -1, + -1, 3303, -1, -1, -1, -1, -1, -1, 1830, 1831, + 1832, 1833, 1834, -1, -1, -1, -1, -1, -1, -1, + 501, -1, -1, -1, -1, -1, -1, 508, 509, 510, + 511, 512, 513, -1, -1, -1, -1, -1, -1, -1, + 3342, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 908, -1, -1, 2804, 912, 913, -1, -1, -1, + -1, -1, 3364, -1, -1, 2900, -1, -1, -1, 2804, + 2905, -1, -1, -1, -1, -1, -1, -1, 2882, -1, + -1, -1, -1, 501, 98, -1, -1, 2997, 3169, 3391, + 508, 509, 510, 511, 512, 513, -1, -1, -1, -1, + -1, -1, 3404, 3405, -1, 3407, 3408, -1, 965, -1, + 3020, -1, 126, 127, 3416, -1, -1, 2952, 2953, -1, + -1, -1, -1, -1, -1, 3427, 983, -1, -1, -1, + -1, -1, 989, -1, -1, 992, -1, -1, 995, 996, + 997, 998, 1964, -1, -1, -1, -1, 3449, -1, -1, + -1, -1, -1, -1, 3456, -1, -1, -1, 172, -1, + -1, 2911, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 8, -1, 2911, 11, 1035, 1036, + -1, 15, 16, 17, 18, 19, 20, 21, -1, -1, + 3100, 3493, -1, -1, -1, 2945, -1, -1, -1, 1056, + -1, -1, 36, -1, -1, -1, 3508, -1, -1, -1, + 2945, -1, 46, -1, -1, -1, -1, -1, 1075, 53, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 1086, + 1087, 1088, -1, 1090, 1091, -1, -1, -1, -1, -1, + -1, 8, -1, -1, 11, -1, 80, -1, 15, 16, + -1, 3055, -1, -1, -1, -1, -1, -1, 3062, 3169, + -1, -1, -1, -1, -1, -1, -1, 1124, -1, -1, + -1, -1, -1, -1, 3024, -1, -1, -1, -1, 46, + -1, -1, -1, -1, 1141, 1142, 53, -1, -1, 3024, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 315, 316, 317, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 80, 3118, -1, -1, 3067, -1, 3123, + 1177, -1, 3157, 3158, 1181, 1182, -1, -1, -1, -1, + -1, -1, 3067, -1, 3169, 1192, 1193, -1, -1, -1, + -1, -1, -1, 177, -1, 3149, 8, -1, -1, 11, + 3431, -1, -1, 15, 16, -1, -1, -1, -1, -1, + 194, -1, -1, -1, -1, 199, 3170, 3171, 382, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 145, 393, + -1, -1, -1, -1, 46, -1, 3296, -1, 222, 223, + -1, 53, 3196, -1, -1, 1252, -1, -1, -1, -1, + -1, 415, -1, 237, 1261, 419, -1, -1, -1, -1, + 177, -1, -1, -1, -1, -1, -1, -1, 80, 3169, + -1, -1, -1, -1, -1, 439, -1, 194, 1285, -1, + -1, -1, 199, 3237, 3169, -1, -1, -1, 452, -1, + -1, 275, -1, -1, 278, -1, -1, -1, -1, 463, + -1, -1, -1, -1, -1, -1, -1, -1, 292, -1, + -1, 295, -1, -1, -1, 479, -1, -1, -1, -1, + 237, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 145, -1, -1, -1, -1, 0, 503, + -1, -1, -1, -1, -1, -1, 2318, -1, -1, -1, + -1, -1, -1, 517, -1, -1, -1, -1, -1, -1, + 22, 2333, 2334, 2335, 1371, 177, -1, -1, -1, -1, + 32, 3431, 34, 35, -1, 292, 2348, -1, -1, 2351, + -1, -1, 194, -1, 2356, 47, -1, 199, -1, -1, + 52, -1, -1, -1, -1, -1, -1, -1, -1, 61, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 394, -1, -1, 75, -1, -1, -1, -1, -1, -1, + -1, -1, 84, -1, 86, 237, -1, 1434, -1, 1436, + 1437, -1, -1, -1, -1, -1, 98, -1, 100, -1, + -1, -1, 1449, 1450, -1, -1, 3431, -1, -1, 111, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 1466, + -1, -1, -1, -1, 126, 127, 128, -1, -1, -1, + 2442, 2443, 2444, 3427, -1, 137, -1, 394, -1, -1, + 292, 143, -1, -1, -1, -1, -1, 993, -1, 151, + -1, 153, 154, -1, -1, -1, -1, -1, -1, -1, + 8, 0, -1, 11, -1, -1, 168, 15, 16, -1, + 172, 19, 20, 21, -1, -1, -1, 501, -1, -1, + 504, 505, 506, -1, 508, 509, 510, 511, 512, 513, + -1, 3431, -1, -1, -1, -1, 198, -1, 46, -1, + -1, -1, -1, 527, -1, 53, 3431, -1, -1, -1, + -1, -1, 214, -1, -1, -1, -1, -1, -1, -1, + -1, 1568, -1, -1, -1, -1, -1, -1, -1, 1576, + -1, -1, 80, -1, -1, -1, -1, -1, 240, -1, + -1, -1, 394, -1, 501, -1, -1, -1, -1, -1, + -1, 508, 509, 510, 511, 512, 513, -1, -1, -1, + -1, 100, -1, -1, -1, 1111, -1, -1, 1615, -1, + 2582, -1, -1, -1, 1621, 1622, 1623, 1624, 1625, 1626, + 1627, 1628, -1, -1, -1, -1, 1633, 1634, -1, -1, + -1, 1638, -1, -1, -1, 1642, -1, -1, 1645, 1646, + 1647, 1648, 1649, 1650, 1651, 1652, 1653, -1, 147, 1656, + -1, 1157, -1, 315, 316, 317, 1663, -1, 1665, -1, + -1, 323, -1, 162, 326, -1, -1, -1, 167, 177, + -1, -1, -1, 172, -1, -1, -1, 1684, -1, -1, + -1, -1, 181, -1, -1, 1191, 194, 186, -1, 501, + -1, 199, -1, -1, -1, 357, 508, 509, 510, 511, + 512, 513, -1, 2675, 366, -1, -1, -1, -1, -1, + -1, 1718, 1719, -1, 222, 223, -1, -1, -1, 218, + 382, -1, -1, -1, -1, -1, -1, 389, -1, 237, + -1, 393, -1, -1, -1, -1, -1, -1, -1, 238, + 1246, 403, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 415, -1, -1, -1, 419, -1, -1, + -1, -1, -1, -1, -1, 2737, 2738, 2739, 2740, -1, + 278, -1, -1, -1, -1, -1, -1, 439, -1, -1, + -1, -1, 1288, -1, 292, -1, -1, -1, 287, 1295, + 452, 290, -1, 455, -1, -1, 458, 296, -1, -1, + -1, 463, 1809, -1, -1, -1, 1813, -1, -1, 1816, + 1817, -1, -1, -1, -1, -1, -1, 479, -1, -1, + -1, 8, -1, -1, 11, -1, -1, -1, 15, 16, + 17, 18, 19, 20, 21, -1, -1, 336, -1, 1345, + 8, 503, -1, 11, -1, -1, -1, 15, 16, 36, + 1857, 19, 20, 21, -1, 517, -1, -1, 520, 46, + -1, -1, 361, 1369, -1, -1, 53, -1, 36, 1876, + 1877, -1, -1, -1, -1, -1, -1, -1, 46, -1, + -1, -1, -1, -1, -1, 53, 394, -1, -1, -1, + -1, -1, -1, 80, -1, -1, -1, -1, 1905, 1906, + -1, 1908, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 1417, 80, 1419, -1, 1421, 1422, 2889, 1424, -1, + 419, 1427, -1, -1, 1430, -1, -1, 1433, -1, -1, + 1937, 1938, 1438, -1, 1941, 1441, -1, -1, 3, -1, + -1, -1, -1, 8, -1, -1, 11, -1, 447, -1, + 15, 16, 17, 18, 19, 20, 21, -1, 457, -1, + -1, -1, -1, 1970, -1, -1, -1, -1, -1, 1976, + -1, 36, -1, -1, 1480, 40, -1, 476, -1, 478, + 479, 46, -1, -1, -1, -1, -1, 1994, 53, 1996, + 177, -1, -1, 501, -1, -1, 504, 505, 506, -1, + 508, 509, 510, 511, 512, 513, -1, 194, -1, 177, + -1, -1, 199, -1, -1, 80, 515, -1, -1, 518, + 519, 520, -1, -1, -1, -1, 194, 2034, -1, -1, + -1, 199, -1, -1, -1, 222, 223, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 237, -1, -1, -1, 222, 223, -1, -1, 1564, -1, + -1, -1, -1, -1, -1, -1, 2073, -1, -1, 237, + -1, 2078, 2079, -1, 1580, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 1590, 1591, 1592, -1, 275, -1, + 1596, 278, -1, -1, 1600, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 292, 8, 275, 295, 11, + 278, -1, 177, 15, 16, 2122, -1, -1, 2125, -1, + 2127, -1, -1, -1, 292, 26, -1, 295, -1, 194, + -1, 32, -1, -1, 199, -1, 2143, -1, -1, 40, + -1, -1, -1, -1, 46, -1, -1, -1, -1, -1, + -1, 53, -1, -1, -1, -1, 1662, 222, 223, 60, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 237, -1, -1, -1, 2183, -1, 80, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 2200, 2201, 1701, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 106, -1, 394, -1, -1, + 275, 1717, 2219, 278, -1, -1, 1722, 3189, -1, -1, + -1, -1, -1, -1, -1, 2232, 394, 292, -1, -1, + 295, -1, -1, 1739, -1, -1, 137, -1, 3210, -1, + -1, -1, -1, 145, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 177, -1, -1, -1, -1, + -1, -1, 2289, -1, -1, -1, -1, -1, 2295, -1, + -1, -1, 194, -1, -1, -1, -1, 199, -1, -1, + 3272, 202, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 501, -1, -1, 504, 505, 506, + -1, 508, 509, 510, 511, 512, 513, -1, -1, 394, + -1, 3303, -1, 501, 521, 237, 504, 505, 506, -1, + 508, 509, 510, 511, 512, 513, -1, 2354, -1, -1, + 251, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 261, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 273, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 292, -1, -1, 294, -1, -1, -1, 1903, -1, -1, + -1, -1, -1, -1, 305, 1911, 1912, -1, 1914, 1915, + 1916, 1917, 1918, 1919, -1, -1, 1922, 1923, 1924, 1925, + 1926, 1927, 1928, 1929, 1930, 1931, 1932, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 501, -1, -1, 504, + 505, 506, -1, 508, 509, 510, 511, 512, 513, -1, + -1, -1, 353, -1, -1, -1, 357, -1, 359, -1, + -1, -1, -1, -1, -1, 8, -1, -1, 11, -1, + -1, -1, 15, 16, 17, 18, 19, 20, 21, -1, + 2487, -1, -1, 384, -1, -1, 2493, 2494, 389, -1, + -1, -1, 394, 36, -1, -1, -1, 2504, -1, -1, + -1, -1, 403, 46, -1, -1, -1, -1, 2515, -1, + 53, 2518, -1, 2520, -1, -1, -1, -1, -1, -1, + -1, 2528, -1, -1, -1, -1, -1, -1, -1, 2536, + 2537, 2037, -1, -1, 2040, -1, 2543, 80, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 2558, -1, -1, -1, -1, -1, -1, -1, 460, + -1, 2568, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 2086, 2588, -1, -1, 2090, 2091, 2092, 2093, 2094, 2095, + 2096, 2097, -1, -1, -1, -1, -1, 2103, 2104, 501, + 2106, 2107, -1, -1, -1, -1, 508, 509, 510, 511, + 512, 513, 2118, -1, -1, 2121, -1, -1, -1, -1, + -1, -1, -1, 2129, 2130, 2131, 2132, 2133, 2134, 2135, + 2136, 2137, 2138, -1, 177, -1, -1, -1, -1, -1, + 2647, -1, 2649, -1, -1, -1, -1, -1, -1, -1, + -1, 194, -1, -1, -1, -1, 199, 8, 2164, -1, + 11, -1, -1, -1, 15, 16, 17, 18, 19, 20, + 21, -1, -1, -1, -1, -1, -1, -1, -1, 222, + 223, -1, -1, -1, -1, 36, -1, -1, -1, 40, + -1, -1, -1, -1, 237, 46, -1, -1, -1, -1, + -1, -1, 53, -1, -1, -1, -1, -1, -1, -1, + -1, 2217, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 80, + -1, -1, 275, -1, -1, 278, -1, 2744, 2745, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 292, + -1, -1, 295, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 2779, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 2290, -1, 2793, -1, -1, -1, + -1, 2798, 2799, -1, 2300, 2301, 2803, -1, -1, -1, + -1, 2808, -1, -1, 2811, 2812, -1, -1, -1, 2816, + 2817, -1, -1, 2820, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 2831, -1, 177, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 194, -1, -1, -1, -1, 199, -1, + -1, 394, -1, -1, -1, -1, -1, -1, -1, 2365, + -1, -1, -1, -1, -1, -1, -1, -1, 2875, -1, + -1, 222, 223, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 2389, 2390, 2391, 237, -1, 2394, 2395, + 2396, 2397, 2398, 2399, -1, 2902, -1, 2403, 2404, 2405, + 2406, 2407, 2408, 2409, 2410, 2411, 2412, -1, -1, -1, + -1, 2417, 2418, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 275, -1, -1, 278, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 2445, + -1, 292, -1, -1, 295, 2451, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 501, -1, + -1, 504, 505, 506, -1, 508, 509, 510, 511, 512, + 513, -1, -1, -1, -1, 518, -1, -1, -1, -1, + 2486, -1, -1, -1, -1, 2992, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 2505, + -1, 8, 2508, 2509, 11, -1, -1, -1, 15, 16, + 2516, 2517, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 2530, 2531, 2532, 2533, -1, 2535, + -1, -1, 3039, 2539, -1, -1, -1, -1, -1, 46, + -1, -1, -1, 394, -1, -1, 53, -1, -1, -1, + 8, -1, -1, 11, -1, -1, -1, 15, 16, 17, + 18, 19, 20, 21, -1, 3072, -1, -1, -1, -1, + -1, -1, -1, 80, -1, -1, 3083, 3084, 36, -1, + 3087, -1, 3089, -1, -1, -1, -1, -1, 46, 2595, + -1, -1, -1, -1, -1, 53, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 3114, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 80, -1, -1, -1, -1, -1, -1, -1, + -1, 3138, -1, -1, -1, -1, -1, -1, 145, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 501, -1, -1, 504, 505, 506, -1, 508, 509, 510, + 511, 512, 513, -1, -1, -1, -1, 518, -1, -1, + 177, 8, -1, -1, 11, -1, -1, -1, 15, 16, + 17, 18, 19, 20, 21, -1, -1, 194, -1, -1, + -1, -1, 199, -1, -1, -1, 2702, -1, -1, 36, + -1, -1, 3209, -1, -1, -1, -1, -1, -1, 46, + -1, -1, -1, -1, -1, -1, 53, -1, 2724, 177, + 3227, -1, -1, -1, 3231, -1, -1, -1, 3235, -1, + 237, -1, -1, -1, -1, -1, 194, -1, -1, 3246, + -1, 199, -1, 80, 3251, -1, 3253, -1, -1, -1, + -1, -1, -1, -1, 3261, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 222, 223, -1, -1, -1, -1, + -1, -1, 3279, -1, 2780, -1, 2782, -1, -1, 237, + -1, -1, 2788, -1, -1, 292, -1, -1, -1, -1, + -1, 2797, -1, -1, 2800, -1, 2802, -1, -1, -1, + 2806, -1, -1, 2809, 2810, -1, 8, 2813, 2814, 11, + -1, -1, -1, 15, 16, 2821, -1, 275, -1, -1, + 278, 3328, -1, -1, 2830, -1, -1, -1, -1, -1, + -1, 3338, -1, -1, 292, -1, -1, 295, -1, 2845, + 177, -1, -1, 3350, 46, -1, -1, -1, -1, -1, + -1, 53, -1, -1, -1, -1, -1, 194, -1, -1, + -1, -1, 199, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 3382, -1, 2883, 80, -1, + -1, -1, -1, -1, -1, 222, 223, 394, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 237, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 8, -1, -1, 11, + -1, -1, -1, 15, 16, 17, 18, 19, 20, 21, + -1, -1, -1, -1, -1, -1, 394, -1, 275, -1, + -1, 278, -1, -1, 36, -1, -1, -1, -1, 41, + -1, -1, -1, -1, 46, 292, -1, -1, 295, -1, + -1, 53, -1, 3470, 3471, 3472, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 177, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 80, -1, + 3497, -1, 194, -1, 501, -1, -1, 199, -1, -1, + -1, 508, 509, 510, 511, 512, 513, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 3022, 3023, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 3538, -1, -1, 126, 237, -1, -1, -1, -1, + -1, 3047, 3048, 501, -1, -1, 504, 505, 506, -1, + 508, 509, 510, 511, 512, 513, -1, 394, -1, -1, + 518, -1, -1, -1, -1, 3071, -1, -1, -1, 3075, + -1, 3077, 3078, 3079, -1, -1, 3082, -1, -1, 3085, + 3086, -1, -1, -1, -1, 177, -1, -1, 3094, -1, + 292, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 194, -1, -1, -1, -1, 199, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 3135, + 222, 223, -1, -1, -1, 3141, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 237, -1, -1, 3154, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 501, -1, -1, 504, 505, 506, + -1, 508, 509, 510, 511, 512, 513, -1, -1, -1, + -1, 518, 3188, 275, -1, -1, 278, -1, -1, -1, + -1, -1, 394, -1, -1, -1, -1, -1, -1, -1, + 292, -1, -1, 295, -1, -1, -1, -1, -1, 3215, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 3248, 3249, 3250, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 3268, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 3280, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 501, + -1, -1, 394, -1, -1, -1, 508, 509, 510, 511, + 512, 513, -1, -1, -1, -1, -1, -1, -1, -1, + 3326, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 3343, -1, -1, + -1, -1, -1, -1, -1, -1, 3352, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 457, -1, -1, -1, -1, + -1, 3377, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 3403, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 501, + -1, -1, 504, 505, 506, -1, 508, 509, 510, 511, + 512, 513, -1, 3, 4, 5, 6, 7, 8, 9, + 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 3446, -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, 3500, 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, -1, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, + -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, - -1, 161, -1, 163, 164, 165, 166, -1, 168, -1, - 170, -1, 172, -1, 174, 175, 176, -1, 178, -1, + 160, 161, -1, 163, 164, 165, 166, -1, 168, -1, + 170, 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, - 190, 191, 192, 193, -1, 195, 196, 197, 198, -1, - 200, 201, 202, 203, 204, 205, 206, -1, 208, -1, + 190, 191, 192, 193, 194, 195, 196, 197, 198, -1, + 200, 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, - -1, 221, -1, -1, 224, -1, 226, 227, 228, 229, - 230, 231, -1, -1, 234, -1, 236, -1, -1, 239, + -1, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, -1, -1, 234, 235, 236, 237, -1, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, -1, - 270, 271, 272, 273, 274, -1, 276, 277, -1, 279, - -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, + 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, - -1, 301, -1, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, -1, 319, - 320, 321, -1, 323, 324, 325, 326, 327, 328, -1, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, -1, 362, 363, -1, 365, 366, 367, 368, 369, + 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, - 380, 381, 382, -1, 384, 385, 386, 387, 388, 389, - 390, 391, 392, -1, -1, 395, 396, 397, 398, -1, + 380, 381, -1, -1, 384, 385, 386, 387, 388, 389, + 390, 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, - 410, 411, 412, 413, 414, -1, -1, 417, 418, 419, - 420, -1, 422, 423, 424, 425, 426, -1, 428, 429, - 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, + 410, 411, 412, 413, 414, -1, -1, 417, 418, -1, + 420, 421, 422, 423, 424, 425, 426, -1, 428, 429, + 430, -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, - 450, 451, 452, 453, 454, 455, 456, -1, 458, 459, - 460, 461, 462, 463, 464, -1, 466, -1, 468, 469, - 470, 471, 472, 473, 474, -1, -1, 477, -1, 479, + 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, + 460, 461, 462, 463, 464, -1, 466, 467, 468, 469, + 470, 471, 472, 473, 474, -1, -1, 477, -1, -1, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, - 500, -1, 3, 503, 5, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 517, -1, -1, - -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, - 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, - 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, - 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, - 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, - -1, -1, 83, 84, 85, 86, 87, 88, -1, 90, - 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, - -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, - 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, - 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, - 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, -1, - 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, - -1, -1, -1, 174, 175, 176, -1, 178, -1, 180, - -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, - 191, 192, 193, -1, 195, 196, 197, 198, -1, 200, - 201, 202, 203, 204, 205, 206, -1, 208, -1, 210, - 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, - 221, -1, -1, 224, -1, 226, 227, 228, 229, 230, - 231, -1, -1, 234, -1, 236, -1, -1, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, -1, 270, - 271, 272, 273, 274, -1, 276, 277, -1, 279, -1, - 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, - -1, 292, 293, 294, -1, -1, 297, 298, 299, -1, - 301, -1, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, - 321, -1, 323, 324, 325, 326, 327, 328, -1, 330, - 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - -1, 362, 363, -1, 365, 366, 367, 368, 369, 370, - 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, - 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, - 391, 392, -1, -1, 395, 396, 397, 398, -1, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, - -1, 422, 423, 424, 425, 426, -1, 428, 429, 430, - -1, -1, 433, 434, 435, 436, 437, -1, 439, 440, - 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, - 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, - 461, 462, 463, 464, -1, 466, -1, 468, 469, 470, - 471, 472, 473, 474, -1, -1, 477, -1, -1, 480, - 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, - 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, - 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 517, -1, -1, 22, - 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, - 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, - 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, - 63, 64, -1, -1, 67, 68, 69, 70, 71, 72, - 73, -1, 75, 76, 77, 78, 79, -1, -1, -1, - 83, 84, 85, 86, 87, 88, -1, 90, 91, 92, - -1, 94, 95, 96, 97, 98, 99, -1, -1, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, - 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, - -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, - -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, -1, 161, -1, - 163, 164, 165, 166, -1, 168, -1, 170, -1, -1, - -1, 174, 175, 176, -1, 178, -1, 180, -1, 182, - 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, - 193, -1, 195, 196, 197, 198, -1, 200, 201, 202, - 203, 204, 205, 206, -1, 208, -1, 210, 211, 212, - 213, 214, 215, 216, 217, -1, 219, -1, 221, -1, - -1, 224, -1, 226, 227, 228, 229, 230, 231, -1, - -1, 234, -1, 236, -1, -1, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, -1, 270, 271, 272, - 273, 274, -1, 276, 277, -1, 279, -1, 281, 282, - 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, - 293, 294, -1, -1, 297, 298, 299, -1, 301, -1, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, -1, -1, -1, -1, 319, 320, 321, -1, - 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, - 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, - 363, -1, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, - -1, 384, 385, 386, 387, 388, 389, 390, 391, 392, - -1, -1, 395, 396, 397, 398, -1, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, -1, -1, 417, 418, -1, 420, -1, 422, - 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, - 433, 434, 435, 436, 437, -1, 439, 440, 441, 442, - 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, - 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, - 463, 464, -1, 466, -1, 468, 469, 470, 471, 472, - 473, 474, -1, -1, 477, -1, -1, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 498, 499, 500, 3, -1, - 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 517, -1, -1, 22, 23, 24, + 500, 501, -1, -1, -1, -1, -1, -1, 508, 509, + 510, -1, -1, -1, -1, 515, -1, 517, -1, -1, + -1, -1, 522, 523, -1, 525, 526, 527, 3, 4, + 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, - -1, -1, -1, -1, -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, + -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, + 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, -1, 161, -1, 163, 164, - 165, 166, -1, 168, -1, 170, -1, -1, -1, 174, - 175, 176, -1, 178, -1, 180, -1, 182, 183, 184, - 185, -1, 187, 188, 189, 190, 191, 192, 193, -1, + 155, 156, 157, 158, 159, 160, 161, -1, 163, 164, + 165, 166, -1, 168, -1, 170, 171, -1, 173, 174, + 175, 176, 177, 178, -1, 180, -1, 182, 183, 184, + 185, -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, - 205, 206, -1, 208, -1, 210, 211, 212, 213, 214, - 215, 216, 217, -1, 219, -1, 221, -1, -1, 224, - -1, 226, 227, 228, 229, 230, 231, -1, -1, 234, - -1, 236, -1, -1, 239, 240, 241, 242, 243, 244, + 205, 206, -1, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, -1, 219, -1, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, -1, -1, 234, + 235, 236, 237, -1, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, -1, 270, 271, 272, 273, 274, - -1, 276, 277, -1, 279, -1, 281, 282, 283, 284, - 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, - -1, -1, 297, 298, 299, -1, 301, -1, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - -1, -1, -1, -1, 319, 320, 321, -1, 323, 324, - 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, - 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, - 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, -1, 362, 363, -1, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, - 385, 386, 387, 388, 389, 390, 391, 392, -1, -1, - 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, - -1, -1, 417, 418, -1, 420, -1, 422, 423, 424, - 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, - 435, 436, 437, -1, 439, 440, 441, 442, 443, 444, - 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, - 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, - -1, 466, -1, 468, 469, 470, 471, 472, 473, 474, - -1, -1, 477, -1, -1, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 499, 500, 3, -1, 5, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 517, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, - 47, 48, -1, 50, 51, 52, 53, 54, -1, 56, - 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, -1, -1, 83, 84, 85, 86, - 87, 88, -1, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, -1, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, -1, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, -1, -1, -1, 174, 175, 176, - -1, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, -1, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, -1, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, -1, -1, 224, -1, 226, - 227, 228, 229, 230, 231, -1, -1, 234, -1, 236, - -1, -1, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, -1, 270, 271, 272, 273, 274, -1, 276, - 277, -1, 279, -1, 281, 282, 283, 284, 285, 286, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, -1, 301, -1, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, -1, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, -1, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, -1, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, -1, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, -1, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, -1, 466, - -1, 468, 469, 470, 471, 472, 473, 474, -1, -1, - 477, -1, -1, 480, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 3, -1, 5, -1, -1, -1, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, + -1, -1, 297, 298, 299, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + -1, -1, -1, -1, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, + 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, + 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, -1, 362, 363, 364, + 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, + 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, + 385, 386, 387, 388, 389, 390, 391, 392, -1, 394, + 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + -1, -1, 417, 418, -1, 420, 421, 422, 423, 424, + 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, + 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, + 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, + 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, + -1, 466, 467, 468, 469, 470, 471, 472, 473, 474, + -1, -1, 477, -1, -1, 480, 481, 482, 483, 484, + 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, + 495, 496, 497, 498, 499, 500, 501, -1, -1, -1, + -1, -1, -1, 508, 509, 510, -1, -1, -1, -1, + 515, -1, 517, -1, -1, -1, -1, 522, 523, -1, + 525, 526, 527, 3, 4, 5, 6, 7, 8, 9, + 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, + -1, 31, 32, 33, -1, -1, -1, -1, -1, 39, + -1, -1, 42, 43, 44, -1, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, + -1, 81, -1, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, + -1, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, 117, 118, -1, + 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, + 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, + 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, -1, 163, 164, 165, 166, -1, 168, -1, + 170, 171, 172, 173, 174, 175, 176, 177, 178, -1, + 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, -1, + 200, 201, 202, 203, 204, 205, 206, -1, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, + -1, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, -1, -1, 234, 235, 236, 237, -1, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, 286, -1, 288, 289, + -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, -1, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, -1, + 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, + 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, + 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, + 380, 381, 382, -1, 384, 385, 386, 387, 388, 389, + 390, 391, 392, 393, 394, 395, 396, 397, 398, -1, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, -1, 417, 418, 419, + 420, 421, 422, 423, 424, 425, 426, -1, 428, 429, + 430, -1, -1, 433, 434, 435, 436, 437, 438, 439, + 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, + 450, 451, 452, 453, 454, 455, 456, -1, 458, 459, + 460, 461, 462, 463, 464, -1, 466, 467, 468, 469, + 470, 471, 472, 473, 474, -1, -1, 477, -1, 479, + 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, + 500, 501, -1, 503, -1, -1, -1, -1, 508, 509, + 510, -1, -1, -1, -1, 515, -1, 517, 518, -1, + -1, -1, 522, 523, -1, 525, 526, 3, 4, 5, + 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, + -1, -1, -1, 39, -1, -1, 42, 43, 44, -1, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, -1, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, 81, -1, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, -1, 120, 121, 122, 123, 124, 125, + 126, 127, 128, 129, 130, 131, -1, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, + 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, 171, 172, 173, 174, 175, + 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, -1, -1, 234, 235, + 236, 237, -1, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, + -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, -1, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, 382, -1, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, + -1, 417, 418, 419, 420, 421, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, 452, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, -1, + 466, 467, 468, 469, 470, 471, 472, 473, 474, -1, + -1, 477, -1, 479, 480, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 501, -1, 503, -1, -1, + -1, -1, 508, 509, 510, -1, -1, -1, -1, 515, + -1, 517, -1, -1, -1, -1, 522, 523, -1, 525, + 526, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 517, -1, -1, 22, 23, 24, 25, 26, 27, 28, - 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 43, 44, -1, 46, 47, 48, - -1, 50, 51, 52, 53, 54, -1, 56, 57, -1, - 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, - 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, - 79, -1, -1, -1, 83, 84, 85, 86, 87, 88, - -1, 90, 91, 92, -1, 94, 95, 96, 97, 98, - 99, -1, -1, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, - -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, - 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, - -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, - 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, -1, 161, -1, 163, 164, 165, 166, -1, 168, - -1, 170, -1, -1, -1, 174, 175, 176, -1, 178, - -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, - 189, 190, 191, 192, 193, -1, 195, 196, 197, 198, - -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, - -1, 210, 211, 212, 213, 214, 215, 216, 217, -1, - 219, -1, 221, -1, -1, 224, -1, 226, 227, 228, - 229, 230, 231, -1, -1, 234, -1, 236, -1, -1, - 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - -1, 270, 271, 272, 273, 274, -1, 276, 277, -1, - 279, -1, 281, 282, 283, 284, 285, 286, -1, 288, - 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, - 299, -1, 301, -1, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, - 319, 320, 321, -1, 323, 324, 325, 326, 327, 328, - -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, - 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, -1, 362, 363, -1, 365, 366, 367, 368, - 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, - 379, 380, 381, -1, -1, 384, 385, 386, 387, 388, - 389, 390, 391, 392, -1, -1, 395, 396, 397, 398, - -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, - -1, 420, -1, 422, 423, 424, 425, 426, -1, 428, - 429, 430, -1, -1, 433, 434, 435, 436, 437, -1, - 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, - 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, - 459, 460, 461, 462, 463, 464, -1, 466, -1, 468, - 469, 470, 471, 472, 473, 474, -1, -1, 477, -1, - -1, 480, 481, 482, 483, 484, 485, 486, 487, 488, - 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, - 499, 500, 3, -1, 5, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 517, -1, - -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, - 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, - 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, - 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, - 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, - -1, -1, 83, 84, 85, 86, 87, 88, -1, 90, - 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, - -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, - 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, - 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, - 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, -1, - 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, - -1, -1, -1, 174, 175, 176, -1, 178, -1, 180, - -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, - 191, 192, 193, -1, 195, 196, 197, 198, -1, 200, - 201, 202, 203, 204, 205, 206, -1, 208, -1, 210, - 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, - 221, -1, -1, 224, -1, 226, 227, 228, 229, 230, - 231, -1, -1, 234, -1, 236, -1, -1, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, -1, 270, - 271, 272, 273, 274, -1, 276, 277, -1, 279, -1, - 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, - -1, 292, 293, 294, -1, -1, 297, 298, 299, -1, - 301, -1, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, - 321, -1, 323, 324, 325, 326, 327, 328, -1, 330, - 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - -1, 362, 363, -1, 365, 366, 367, 368, 369, 370, - 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, - 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, - 391, 392, -1, -1, 395, 396, 397, 398, -1, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, - -1, 422, 423, 424, 425, 426, -1, 428, 429, 430, - -1, -1, 433, 434, 435, 436, 437, -1, 439, 440, - 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, - 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, - 461, 462, 463, 464, -1, 466, -1, 468, 469, 470, - 471, 472, 473, 474, -1, -1, 477, -1, -1, 480, - 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, - 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, - 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 517, -1, -1, 22, - 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, - 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, - 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, - 63, 64, -1, -1, 67, 68, 69, 70, 71, 72, - 73, -1, 75, 76, 77, 78, 79, -1, -1, -1, - 83, 84, 85, 86, 87, 88, -1, 90, 91, 92, - -1, 94, 95, 96, 97, 98, 99, -1, -1, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, - 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, - -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, - -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, -1, 161, -1, - 163, 164, 165, 166, -1, 168, -1, 170, -1, -1, - -1, 174, 175, 176, -1, 178, -1, 180, -1, 182, - 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, - 193, -1, 195, 196, 197, 198, -1, 200, 201, 202, - 203, 204, 205, 206, -1, 208, -1, 210, 211, 212, - 213, 214, 215, 216, 217, -1, 219, -1, 221, -1, - -1, 224, -1, 226, 227, 228, 229, 230, 231, -1, - -1, 234, -1, 236, -1, -1, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, -1, 270, 271, 272, - 273, 274, -1, 276, 277, -1, 279, -1, 281, 282, - 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, - 293, 294, -1, -1, 297, 298, 299, -1, 301, -1, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, -1, -1, -1, -1, 319, 320, 321, -1, - 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, - 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, - 363, -1, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, - -1, 384, 385, 386, 387, 388, 389, 390, 391, 392, - -1, -1, 395, 396, 397, 398, -1, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, -1, -1, 417, 418, -1, 420, -1, 422, - 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, - 433, 434, 435, 436, 437, -1, 439, 440, 441, 442, - 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, - 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, - 463, 464, -1, 466, -1, 468, 469, 470, 471, 472, - 473, 474, -1, -1, 477, -1, -1, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 498, 499, 500, 3, -1, + 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, + 32, 33, -1, -1, -1, -1, -1, 39, -1, -1, + 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, + -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, -1, 120, 121, + 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, + -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, + 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, + -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, + 172, 173, 174, 175, 176, 177, 178, -1, 180, -1, + 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, + 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + -1, -1, 234, 235, 236, 237, -1, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, + 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, -1, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, + 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, + 382, -1, 384, 385, 386, 387, 388, 389, 390, 391, + 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, -1, -1, 417, 418, 419, 420, 421, + 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, + -1, 433, 434, 435, 436, 437, 438, 439, 440, 441, + 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, + 452, 453, 454, 455, 456, -1, 458, 459, 460, 461, + 462, 463, 464, -1, 466, 467, 468, 469, 470, 471, + 472, 473, 474, -1, -1, 477, -1, 479, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, + -1, 503, -1, -1, -1, -1, 508, 509, 510, -1, + -1, -1, -1, 515, -1, 517, -1, -1, -1, -1, + 522, 523, -1, 525, 526, 3, 4, 5, 6, 7, + 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, -1, -1, -1, 37, + -1, 39, -1, -1, 42, 43, 44, -1, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + -1, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, -1, 75, 76, 77, + 78, 79, -1, 81, -1, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, -1, 94, 95, 96, 97, + 98, 99, -1, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, + 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, + 128, 129, 130, 131, 132, -1, 134, 135, 136, 137, + 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 160, 161, -1, 163, 164, 165, 166, -1, + 168, -1, 170, 171, -1, 173, 174, 175, 176, 177, + 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + 198, -1, 200, 201, 202, 203, 204, 205, 206, -1, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + -1, 219, -1, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, -1, -1, 234, 235, 236, 237, + -1, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, -1, + 288, 289, -1, -1, 292, 293, 294, -1, -1, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, + -1, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, + 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, -1, 362, 363, 364, 365, 366, 367, + 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, + 378, 379, 380, 381, -1, 383, 384, 385, 386, 387, + 388, 389, 390, 391, 392, -1, 394, 395, 396, 397, + 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, + 408, 409, 410, 411, 412, 413, 414, -1, -1, 417, + 418, -1, 420, 421, 422, 423, 424, 425, 426, -1, + 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, + 438, 439, 440, 441, 442, 443, 444, 445, 446, -1, + -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, + 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, + 468, 469, 470, 471, 472, 473, 474, -1, -1, 477, + -1, -1, 480, 481, 482, 483, 484, 485, 486, 487, + 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, + 498, 499, 500, 501, -1, -1, -1, -1, -1, -1, + 508, 509, 510, -1, -1, -1, -1, 515, -1, 517, + 518, -1, -1, -1, 522, 523, -1, 525, 526, 3, + 4, 5, 6, 7, -1, 9, 10, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, + 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, + -1, -1, -1, -1, -1, 39, -1, -1, 42, 43, + 44, -1, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, -1, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + -1, 75, 76, 77, 78, 79, -1, 81, -1, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, -1, + 94, 95, 96, 97, 98, 99, -1, 101, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, + 124, 125, 126, 127, 128, 129, 130, 131, -1, -1, + 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, + 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, 160, 161, -1, 163, + 164, 165, 166, -1, 168, -1, 170, 171, 172, 173, + 174, 175, 176, 177, 178, -1, 180, -1, 182, 183, + 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, + 194, 195, 196, 197, 198, -1, 200, 201, 202, 203, + 204, 205, 206, -1, 208, 209, 210, 211, 212, 213, + 214, 215, 216, 217, -1, 219, -1, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, -1, -1, + 234, 235, 236, 237, -1, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, + 274, -1, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, + 294, -1, -1, 297, 298, 299, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, -1, 319, 320, 321, 322, 323, + 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, + 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, + 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, + 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 375, 376, 377, 378, 379, 380, 381, 382, -1, + 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, + 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, + 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, + 414, 415, -1, 417, 418, 419, 420, 421, 422, 423, + 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, + 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, + 444, 445, 446, -1, -1, 449, 450, 451, 452, 453, + 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, + 464, -1, 466, 467, 468, 469, 470, 471, 472, 473, + 474, -1, -1, 477, -1, 479, 480, 481, 482, 483, + 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 499, 500, -1, -1, 503, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 517, -1, -1, 22, 23, 24, - 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, - -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, - -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, - -1, -1, 67, 68, 69, 70, 71, 72, 73, -1, - 75, 76, 77, 78, 79, -1, -1, -1, 83, 84, - 85, 86, 87, 88, -1, 90, 91, 92, -1, 94, - 95, 96, 97, 98, 99, -1, -1, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, - 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, - 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, - 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, -1, 161, -1, 163, 164, - 165, 166, -1, 168, -1, 170, -1, -1, -1, 174, - 175, 176, -1, 178, -1, 180, -1, 182, 183, 184, - 185, -1, 187, 188, 189, 190, 191, 192, 193, -1, - 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, - 205, 206, -1, 208, -1, 210, 211, 212, 213, 214, - 215, 216, 217, -1, 219, -1, 221, -1, -1, 224, - -1, 226, 227, 228, 229, 230, 231, -1, -1, 234, - -1, 236, -1, -1, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, -1, 270, 271, 272, 273, 274, - -1, 276, 277, -1, 279, -1, 281, 282, 283, 284, - 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, - -1, -1, 297, 298, 299, -1, 301, -1, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - -1, -1, -1, -1, 319, 320, 321, -1, 323, 324, - 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, - 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, - 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, -1, 362, 363, -1, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, - 385, 386, 387, 388, 389, 390, 391, 392, -1, -1, - 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, - -1, -1, 417, 418, -1, 420, -1, 422, 423, 424, - 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, - 435, 436, 437, -1, 439, 440, 441, 442, 443, 444, - 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, - 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, - -1, 466, -1, 468, 469, 470, 471, 472, 473, 474, - -1, -1, 477, -1, -1, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 499, 500, 3, -1, -1, -1, + -1, 515, -1, 517, -1, -1, -1, -1, 522, 523, + -1, 525, 526, 3, 4, 5, 6, 7, 8, 9, + 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, + -1, 31, 32, 33, -1, -1, -1, -1, -1, 39, + -1, -1, 42, 43, 44, -1, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, + -1, 81, -1, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, + -1, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, 117, 118, -1, + 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, + 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, + 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, -1, 163, 164, 165, 166, -1, 168, -1, + 170, 171, 172, 173, 174, 175, 176, 177, 178, -1, + 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, -1, + 200, 201, 202, 203, 204, 205, 206, -1, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, + -1, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, -1, 233, 234, 235, 236, 237, -1, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, 286, -1, 288, 289, + -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, -1, + 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, + 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, + 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, + 380, 381, -1, -1, 384, 385, 386, 387, 388, 389, + 390, 391, 392, -1, 394, 395, 396, 397, 398, -1, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, -1, -1, 417, 418, -1, + 420, 421, 422, 423, 424, 425, 426, -1, 428, 429, + 430, -1, 432, 433, 434, 435, 436, 437, 438, 439, + 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, + 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, + 460, 461, 462, 463, 464, -1, 466, 467, 468, 469, + 470, 471, 472, 473, 474, -1, -1, 477, -1, -1, + 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, + 500, 501, -1, -1, -1, -1, -1, -1, 508, 509, + 510, -1, -1, -1, -1, 515, -1, 517, -1, -1, + -1, -1, 522, 523, -1, 525, 526, 3, 4, 5, + 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, + -1, 37, -1, 39, -1, -1, 42, 43, 44, -1, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, -1, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, 81, -1, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, -1, 120, 121, 122, 123, 124, 125, + -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, + 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, 171, -1, 173, 174, 175, + 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, -1, -1, 234, 235, + 236, 237, -1, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, + -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, -1, 383, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, 394, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, 465, + 466, 467, 468, 469, 470, 471, 472, 473, 474, -1, + -1, 477, -1, -1, 480, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 501, -1, -1, -1, -1, + -1, -1, 508, 509, 510, -1, -1, -1, -1, 515, + -1, 517, -1, -1, -1, -1, 522, 523, -1, 525, + 526, 3, 4, 5, 6, 7, 8, 9, 10, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, + 32, 33, -1, -1, -1, 37, -1, 39, -1, -1, + 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, + -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, -1, 120, 121, + 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, + -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, + 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, + -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, + -1, 173, 174, 175, 176, 177, 178, -1, 180, -1, + 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, + 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + -1, -1, 234, 235, 236, 237, -1, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, + 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, + 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, + -1, 383, 384, 385, 386, 387, 388, 389, 390, 391, + 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, -1, -1, 417, 418, -1, 420, 421, + 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, + -1, 433, 434, 435, 436, 437, 438, 439, 440, 441, + 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, + -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, + 462, 463, 464, -1, 466, 467, 468, 469, 470, 471, + 472, 473, 474, -1, -1, 477, -1, -1, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, + -1, -1, -1, -1, -1, -1, 508, 509, 510, -1, + -1, -1, -1, 515, -1, 517, 518, -1, -1, -1, + 522, 523, -1, 525, 526, 3, 4, 5, 6, 7, + 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, -1, -1, -1, -1, + 38, 39, -1, -1, 42, 43, 44, -1, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + -1, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, -1, 75, 76, 77, + 78, 79, -1, 81, -1, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, -1, 94, 95, 96, 97, + 98, 99, -1, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, + 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, + 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, + 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 160, 161, -1, 163, 164, 165, 166, -1, + 168, -1, 170, 171, -1, 173, 174, 175, 176, 177, + 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + 198, -1, 200, 201, 202, 203, 204, 205, 206, -1, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + -1, 219, -1, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, -1, -1, 234, 235, 236, 237, + -1, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, -1, + 288, 289, -1, -1, 292, 293, 294, -1, -1, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, + -1, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, + 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, -1, 362, 363, 364, 365, 366, 367, + 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, + 378, 379, 380, 381, -1, -1, 384, 385, 386, 387, + 388, 389, 390, 391, 392, -1, 394, 395, 396, 397, + 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, + 408, 409, 410, 411, 412, 413, 414, -1, -1, 417, + 418, -1, 420, 421, 422, 423, 424, 425, 426, -1, + 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, + 438, 439, 440, 441, 442, 443, 444, 445, 446, -1, + -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, + 458, 459, 460, 461, 462, 463, 464, -1, 466, 467, + 468, 469, 470, 471, 472, 473, 474, -1, -1, 477, + -1, -1, 480, 481, 482, 483, 484, 485, 486, 487, + 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, + 498, 499, 500, 501, -1, -1, -1, -1, -1, -1, + 508, 509, 510, -1, -1, -1, -1, 515, -1, 517, + -1, -1, -1, -1, 522, 523, -1, 525, 526, 3, + 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, + 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, + -1, -1, -1, 37, -1, 39, -1, -1, 42, 43, + 44, -1, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, -1, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + -1, 75, 76, 77, 78, 79, -1, 81, -1, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, -1, + 94, 95, 96, 97, 98, 99, -1, 101, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, 117, 118, -1, 120, 121, 122, 123, + 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, + 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, + 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, 160, 161, -1, 163, + 164, 165, 166, -1, 168, -1, 170, 171, -1, 173, + 174, 175, 176, 177, 178, -1, 180, -1, 182, 183, + 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, + 194, 195, 196, 197, 198, -1, 200, 201, 202, 203, + 204, 205, 206, -1, 208, 209, 210, 211, 212, 213, + 214, 215, 216, 217, -1, 219, -1, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, -1, -1, + 234, 235, 236, 237, -1, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, + 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, + 294, -1, -1, 297, 298, 299, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, -1, -1, -1, -1, 319, 320, 321, 322, 323, + 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, + 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, + 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, + 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 375, 376, 377, 378, 379, 380, 381, -1, 383, + 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, + 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, + 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, + 414, -1, -1, 417, 418, -1, 420, 421, 422, 423, + 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, + 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, + 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, + 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, + 464, -1, 466, 467, 468, 469, 470, 471, 472, 473, + 474, -1, -1, 477, -1, -1, 480, 481, 482, 483, + 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 499, 500, 501, -1, -1, + -1, -1, -1, -1, 508, 509, 510, -1, -1, -1, + -1, 515, -1, 517, 518, -1, -1, -1, 522, 523, + -1, 525, 526, 3, 4, 5, 6, 7, 8, 9, + 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, + -1, 31, 32, 33, -1, -1, -1, 37, -1, 39, + -1, -1, 42, 43, 44, -1, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, + -1, 81, -1, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, + -1, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, 117, 118, -1, + 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, + 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, + 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, -1, 163, 164, 165, 166, -1, 168, -1, + 170, 171, -1, 173, 174, 175, 176, 177, 178, -1, + 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, -1, + 200, 201, 202, 203, 204, 205, 206, -1, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, + -1, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, -1, -1, 234, 235, 236, 237, -1, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, 286, -1, 288, 289, + -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, -1, + 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, + 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, + 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, + 380, 381, -1, 383, 384, 385, 386, 387, 388, 389, + 390, 391, 392, -1, 394, 395, 396, 397, 398, -1, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, -1, -1, 417, 418, -1, + 420, 421, 422, 423, 424, 425, 426, -1, 428, 429, + 430, -1, -1, 433, 434, 435, 436, 437, 438, 439, + 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, + 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, + 460, 461, 462, 463, 464, -1, 466, 467, 468, 469, + 470, 471, 472, 473, 474, -1, -1, 477, -1, -1, + 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, + 500, 501, -1, -1, -1, -1, -1, -1, 508, 509, + 510, -1, -1, -1, -1, 515, -1, 517, -1, -1, + -1, -1, 522, 523, -1, 525, 526, 3, 4, 5, + 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, -1, -1, + -1, -1, -1, 39, -1, -1, 42, 43, 44, -1, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, -1, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, 81, -1, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, -1, 120, 121, 122, 123, 124, 125, + -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, + 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, 171, -1, 173, 174, 175, + 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, -1, -1, 234, 235, + 236, 237, -1, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, + -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, 394, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, -1, + 466, 467, 468, 469, 470, 471, 472, 473, 474, -1, + -1, 477, -1, -1, 480, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 501, -1, -1, -1, -1, + -1, -1, 508, 509, 510, -1, -1, -1, -1, 515, + -1, 517, -1, -1, -1, -1, 522, 523, -1, 525, + 526, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 517, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, - 47, 48, -1, 50, 51, 52, 53, 54, -1, 56, - 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, -1, -1, 83, 84, 85, 86, - 87, 88, -1, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, -1, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, -1, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, -1, -1, -1, 174, 175, 176, - -1, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, -1, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, -1, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, -1, -1, 224, -1, 226, - 227, 228, 229, 230, 231, -1, -1, 234, -1, 236, - -1, -1, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, -1, 270, 271, 272, 273, 274, -1, 276, - 277, -1, 279, -1, 281, 282, 283, 284, 285, 286, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, -1, 301, -1, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, -1, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, -1, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, -1, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, -1, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, -1, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, -1, 466, - -1, 468, 469, 470, 471, 472, 473, 474, -1, -1, - 477, -1, -1, 480, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, -1, 3, 4, 5, -1, -1, - 8, 9, -1, -1, -1, -1, -1, 15, 16, -1, - 517, 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, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, -1, -1, -1, -1, -1, 39, -1, -1, + 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, + -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, -1, 120, 121, + 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, + -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, + 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, + -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, + -1, 173, 174, 175, 176, 177, 178, -1, 180, -1, + 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, + 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + -1, -1, 234, 235, 236, 237, -1, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, + 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, + 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, + -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, + 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, -1, -1, 417, 418, -1, 420, 421, + 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, + -1, 433, 434, 435, 436, 437, 438, 439, 440, 441, + 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, + -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, + 462, 463, 464, -1, 466, 467, 468, 469, 470, 471, + 472, 473, 474, -1, -1, 477, -1, -1, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, + -1, -1, -1, -1, -1, -1, 508, 509, 510, -1, + -1, -1, -1, 515, -1, 517, -1, -1, -1, -1, + 522, 523, -1, 525, 526, 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, 119, 120, 121, 122, 123, 124, 125, 126, 127, - 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, - 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, - 148, 149, 150, 151, -1, 153, 154, 155, 156, 157, - 158, -1, 160, 161, 162, 163, 164, 165, 166, 167, - 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, - 178, 179, 180, 181, -1, -1, 184, 185, 186, 187, + 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, + 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, + 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 160, 161, -1, 163, 164, 165, 166, -1, + 168, -1, 170, 171, 172, 173, 174, 175, 176, 177, + 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + 198, -1, 200, 201, 202, 203, 204, 205, 206, -1, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + -1, 219, -1, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, -1, -1, 234, 235, 236, 237, + -1, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, -1, + 288, 289, -1, -1, 292, 293, 294, -1, -1, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, + -1, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, + 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, -1, 362, 363, 364, 365, 366, 367, + 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, + 378, 379, 380, 381, -1, -1, 384, 385, 386, 387, + 388, 389, 390, 391, 392, -1, 394, 395, 396, 397, + 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, + 408, 409, 410, 411, 412, 413, 414, -1, -1, 417, + 418, -1, 420, 421, 422, 423, 424, 425, 426, -1, + 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, + 438, 439, 440, 441, 442, 443, 444, 445, 446, -1, + -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, + 458, 459, 460, 461, 462, 463, 464, -1, 466, 467, + 468, 469, 470, 471, 472, 473, 474, -1, -1, 477, + -1, -1, 480, 481, 482, 483, 484, 485, 486, 487, + 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, + 498, 499, 500, 501, -1, -1, -1, -1, -1, -1, + 508, 509, 510, -1, -1, -1, -1, 515, -1, 517, + -1, -1, -1, -1, 522, 523, -1, 525, 526, 3, + 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, + 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, + -1, -1, -1, -1, -1, 39, -1, -1, 42, 43, + 44, -1, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, -1, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + -1, 75, 76, 77, 78, 79, -1, 81, -1, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, -1, + 94, 95, 96, 97, 98, 99, -1, 101, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, 117, 118, -1, 120, 121, 122, 123, + 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, + 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, + 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, 160, 161, -1, 163, + 164, 165, 166, -1, 168, -1, 170, 171, -1, 173, + 174, 175, 176, 177, 178, -1, 180, -1, 182, 183, + 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, + 194, 195, 196, 197, 198, -1, 200, 201, 202, 203, + 204, 205, 206, -1, 208, 209, 210, 211, 212, 213, + 214, 215, 216, 217, -1, 219, -1, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, -1, -1, + 234, 235, 236, 237, -1, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, + 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, + 294, -1, -1, 297, 298, 299, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, -1, -1, -1, -1, 319, 320, 321, 322, 323, + 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, + 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, + 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, + 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, + 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, + 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, + 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, + 414, -1, -1, 417, 418, -1, 420, 421, 422, 423, + 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, + 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, + 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, + 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, + 464, -1, 466, 467, 468, 469, 470, 471, 472, 473, + 474, -1, -1, 477, -1, -1, 480, 481, 482, 483, + 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 499, 500, 501, -1, -1, + -1, -1, -1, -1, 508, 509, 510, -1, -1, -1, + -1, 515, -1, 517, 518, -1, -1, -1, 522, 523, + -1, 525, 526, 3, 4, 5, 6, 7, 8, 9, + 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, + -1, 31, 32, 33, -1, -1, -1, -1, -1, 39, + -1, -1, 42, 43, 44, -1, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, + -1, 81, -1, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, + -1, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, 117, 118, -1, + 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, + 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, + 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, -1, 163, 164, 165, 166, -1, 168, -1, + 170, 171, -1, 173, 174, 175, 176, 177, 178, -1, + 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, -1, + 200, 201, 202, 203, 204, 205, 206, -1, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, + -1, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, -1, -1, 234, 235, 236, 237, -1, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, 286, -1, 288, 289, + -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, -1, + 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, + 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, + 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, + 380, 381, -1, -1, 384, 385, 386, 387, 388, 389, + 390, 391, 392, -1, 394, 395, 396, 397, 398, -1, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, -1, -1, 417, 418, 419, + 420, 421, 422, 423, 424, 425, 426, -1, 428, 429, + 430, -1, -1, 433, 434, 435, 436, 437, 438, 439, + 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, + 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, + 460, 461, 462, 463, 464, -1, 466, 467, 468, 469, + 470, 471, 472, 473, 474, -1, -1, 477, -1, -1, + 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, + 500, 501, -1, -1, -1, -1, -1, -1, 508, 509, + 510, -1, -1, -1, -1, 515, -1, 517, -1, -1, + -1, -1, 522, 523, -1, 525, 526, 3, 4, 5, + 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, + -1, -1, -1, 39, -1, -1, 42, 43, 44, -1, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, -1, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, 81, -1, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, -1, 120, 121, 122, 123, 124, 125, + -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, + 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, 171, -1, 173, 174, 175, + 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, -1, -1, 234, 235, + 236, 237, -1, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, + -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, 394, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, -1, + 466, 467, 468, 469, 470, 471, 472, 473, 474, -1, + 476, 477, -1, -1, 480, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 501, -1, -1, -1, -1, + -1, -1, 508, 509, 510, -1, -1, -1, -1, 515, + -1, 517, -1, -1, -1, -1, 522, 523, -1, 525, + 526, 3, 4, 5, 6, 7, 8, 9, 10, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, -1, -1, -1, -1, -1, 39, -1, -1, + 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, + -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, -1, 120, 121, + 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, + -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, + 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, + -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, + -1, 173, 174, 175, 176, 177, 178, -1, 180, -1, + 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, + 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + -1, -1, 234, 235, 236, 237, -1, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, + 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, + 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, + -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, + 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, -1, -1, 417, 418, -1, 420, 421, + 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, + -1, 433, 434, 435, 436, 437, 438, 439, 440, 441, + 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, + -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, + 462, 463, 464, -1, 466, 467, 468, 469, 470, 471, + 472, 473, 474, -1, -1, 477, -1, -1, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, + -1, -1, -1, -1, -1, -1, 508, 509, 510, -1, + -1, -1, -1, 515, -1, 517, -1, -1, -1, -1, + 522, 523, -1, 525, 526, 3, 4, 5, 6, 7, + 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, + 28, 29, -1, 31, 32, 33, -1, -1, -1, -1, + -1, 39, -1, -1, 42, 43, 44, -1, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + -1, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, -1, 75, 76, 77, + 78, 79, -1, 81, -1, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, -1, 94, 95, 96, 97, + 98, 99, -1, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, + 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, + 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, + 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 160, 161, -1, 163, 164, 165, 166, -1, + 168, -1, 170, 171, -1, 173, 174, 175, 176, 177, + 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, - 208, 209, -1, 211, 212, 213, 214, 215, 216, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, - 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 198, -1, 200, 201, 202, 203, 204, 205, 206, -1, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + -1, 219, -1, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, -1, -1, 234, 235, 236, 237, + -1, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, -1, 282, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, - 298, -1, 300, 301, 302, -1, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, -1, 322, 323, 324, -1, 326, 327, - 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, - 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, + 278, 279, 280, 281, 282, 283, 284, 285, 286, -1, + 288, 289, -1, -1, 292, 293, 294, -1, -1, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, + -1, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, + 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, + 358, 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, - 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, 412, 413, -1, 415, 416, 417, - 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, - 428, 429, 430, 431, 432, 433, 434, -1, 436, -1, - 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, - 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, - 458, 459, 460, 461, 462, -1, 464, 465, 466, 467, - 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, - 478, 479, 480, 481, 482, 483, 484, 485, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 497, - 498, 499, 500, -1, 3, -1, 504, 505, 506, 8, - 508, 509, 510, 511, 512, 513, 15, 16, -1, -1, - 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, - 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 43, 44, -1, 46, 47, 48, - -1, 50, 51, 52, 53, 54, -1, 56, 57, -1, - 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, - 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, - 79, -1, -1, -1, 83, 84, 85, 86, 87, 88, - -1, 90, 91, 92, -1, 94, 95, 96, 97, 98, - 99, -1, -1, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, - -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, - 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, - -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, - 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, -1, 161, -1, 163, 164, 165, 166, -1, 168, - -1, 170, -1, -1, -1, 174, 175, 176, -1, 178, - -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, - 189, 190, 191, 192, 193, -1, 195, 196, 197, 198, - -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, - -1, 210, 211, 212, 213, 214, 215, 216, 217, -1, - 219, -1, 221, -1, -1, 224, -1, 226, 227, 228, - 229, 230, 231, -1, -1, 234, -1, 236, -1, -1, - 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - -1, 270, 271, 272, 273, 274, -1, 276, 277, -1, - 279, -1, 281, 282, 283, 284, 285, 286, -1, 288, - 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, - 299, -1, 301, -1, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, - 319, 320, 321, -1, 323, 324, 325, 326, 327, 328, - -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, - 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, -1, 362, 363, -1, 365, 366, 367, 368, - 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, - 379, 380, 381, -1, -1, 384, 385, 386, 387, 388, - 389, 390, 391, 392, -1, -1, 395, 396, 397, 398, - -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, - -1, 420, -1, 422, 423, 424, 425, 426, -1, 428, - 429, 430, -1, -1, 433, 434, 435, 436, 437, -1, - 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, - 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, - 459, 460, 461, 462, 463, 464, -1, 466, -1, 468, - 469, 470, 471, 472, 473, 474, -1, -1, 477, -1, - -1, 480, 481, 482, 483, 484, 485, 486, 487, 488, - 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, - 499, 500, -1, -1, -1, 504, 505, 506, -1, 508, - 509, 510, 511, 512, 513, 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, -1, 177, 53, 15, 16, 17, 18, - 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, - -1, 194, -1, -1, -1, -1, 199, 36, -1, -1, - -1, -1, 80, -1, -1, -1, -1, 46, -1, -1, - -1, -1, -1, 177, 53, -1, -1, -1, -1, 222, - 223, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 194, -1, -1, -1, 237, 199, -1, -1, -1, -1, - -1, 80, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 177, -1, -1, -1, -1, -1, 222, 223, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 194, - -1, -1, 275, 237, 199, 278, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 292, - -1, -1, 295, -1, -1, -1, -1, 222, 223, 177, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 275, 237, -1, 278, -1, 194, -1, -1, -1, - -1, 199, -1, -1, -1, -1, -1, -1, 292, -1, - -1, 295, -1, -1, -1, -1, -1, -1, 177, -1, - -1, -1, -1, -1, 222, 223, -1, -1, -1, -1, - 275, -1, -1, 278, -1, 194, -1, -1, -1, 237, - 199, -1, -1, -1, -1, -1, -1, 292, -1, -1, - 295, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 222, 223, -1, -1, -1, -1, -1, - -1, 394, -1, -1, -1, -1, -1, 275, 237, -1, - 278, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 292, -1, -1, 295, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 394, -1, -1, -1, -1, -1, 275, -1, -1, 278, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 292, -1, -1, 295, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 394, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 501, -1, - -1, 504, 505, 506, -1, 508, 509, 510, 511, 512, - 513, -1, -1, -1, -1, 518, 394, -1, -1, -1, - -1, -1, 8, -1, -1, 11, -1, -1, -1, 15, - 16, 17, 18, 19, 20, 21, -1, 501, -1, -1, - 504, 505, 506, -1, 508, 509, 510, 511, 512, 513, - 36, -1, -1, -1, 518, 394, -1, -1, -1, -1, - 46, -1, -1, -1, -1, -1, -1, 53, -1, -1, - -1, -1, -1, -1, -1, -1, 501, -1, -1, 504, - 505, 506, -1, 508, 509, 510, 511, 512, 513, -1, - -1, -1, -1, 518, 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, 501, -1, -1, 504, 505, 506, -1, - 508, 509, 510, 511, 512, 513, 36, -1, -1, -1, - 518, -1, -1, -1, -1, -1, 46, 8, -1, -1, - 11, -1, -1, 53, 15, 16, 17, 18, 19, 20, - 21, -1, 501, -1, -1, 504, 505, 506, -1, 508, - 509, 510, 511, 512, 513, 36, -1, -1, -1, 518, - 80, -1, -1, -1, -1, 46, 8, -1, -1, 11, - -1, 177, 53, 15, 16, 17, 18, 19, 20, 21, - -1, -1, -1, -1, -1, -1, -1, -1, 194, -1, - -1, -1, -1, 199, 36, -1, -1, -1, -1, 80, - -1, -1, -1, -1, 46, -1, -1, -1, -1, -1, - -1, 53, -1, -1, -1, -1, 222, 223, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 237, -1, -1, -1, -1, -1, -1, 80, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 8, -1, -1, 11, -1, 177, -1, 15, - 16, 17, 18, 19, 20, 21, -1, -1, -1, 275, - -1, -1, 278, -1, 194, -1, -1, -1, -1, 199, - 36, -1, -1, -1, -1, -1, 292, -1, -1, 295, - 46, -1, -1, -1, -1, -1, 177, 53, -1, -1, - -1, -1, 222, 223, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 194, -1, -1, -1, 237, 199, -1, - -1, -1, -1, -1, 80, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 177, -1, -1, -1, -1, - -1, 222, 223, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 194, -1, -1, 275, 237, 199, 278, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 292, -1, -1, 295, -1, -1, -1, -1, - 222, 223, -1, -1, -1, -1, -1, -1, 394, -1, - -1, -1, -1, -1, 275, 237, -1, 278, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 292, -1, -1, 295, -1, -1, -1, -1, -1, - -1, 177, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 275, -1, -1, 278, -1, 194, -1, - -1, -1, -1, 199, -1, -1, -1, -1, -1, -1, - 292, -1, -1, 295, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 222, 223, -1, -1, - -1, -1, -1, -1, 394, -1, -1, -1, -1, -1, - -1, 237, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 501, -1, -1, 504, 505, - 506, -1, 508, 509, 510, 511, 512, 513, -1, -1, - -1, -1, 518, 394, -1, -1, -1, -1, -1, 275, - -1, -1, 278, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 292, -1, -1, 295, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 394, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 501, -1, -1, 504, 505, 506, -1, 508, 509, - 510, 511, 512, 513, -1, -1, -1, -1, 518, -1, - -1, -1, -1, -1, -1, 8, -1, -1, 11, -1, - -1, -1, 15, 16, 17, 18, 19, 20, 21, -1, - 501, -1, -1, 504, 505, 506, -1, 508, 509, 510, - 511, 512, 513, 36, -1, 516, -1, -1, 394, -1, - -1, -1, -1, 46, -1, -1, -1, -1, -1, -1, - 53, -1, -1, -1, -1, -1, -1, -1, -1, 501, - -1, -1, 504, 505, 506, -1, 508, 509, 510, 511, - 512, 513, -1, -1, 516, -1, -1, 80, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 501, -1, -1, 504, 505, - 506, -1, 508, 509, 510, 511, 512, 513, -1, -1, - 516, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 177, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 194, -1, -1, -1, -1, 199, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 222, - 223, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 237, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 275, -1, -1, 278, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 292, - -1, -1, 295, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 394, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 378, 379, 380, 381, -1, -1, 384, 385, 386, 387, + 388, 389, 390, 391, 392, -1, 394, 395, 396, 397, + 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, + 408, 409, 410, 411, 412, 413, 414, -1, -1, 417, + 418, 419, 420, 421, 422, 423, 424, 425, 426, -1, + 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, + 438, 439, 440, 441, 442, 443, 444, 445, 446, -1, + -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, + 458, 459, 460, 461, 462, 463, 464, -1, 466, 467, + 468, 469, 470, 471, 472, 473, 474, -1, -1, 477, + -1, -1, 480, 481, 482, 483, 484, 485, 486, 487, + 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, + 498, 499, 500, 501, -1, -1, -1, -1, -1, -1, + 508, 509, 510, -1, -1, -1, -1, 515, -1, 517, + -1, -1, -1, -1, 522, 523, -1, 525, 526, 3, + 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, + 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, + -1, -1, -1, -1, -1, 39, -1, -1, 42, 43, + 44, -1, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, -1, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + -1, 75, 76, 77, 78, 79, -1, 81, -1, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, -1, + 94, 95, 96, 97, 98, 99, -1, 101, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, 117, 118, -1, 120, 121, 122, 123, + 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, + 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, + 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, 160, 161, -1, 163, + 164, 165, 166, -1, 168, -1, 170, 171, -1, 173, + 174, 175, 176, 177, 178, -1, 180, -1, 182, 183, + 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, + 194, 195, 196, 197, 198, -1, 200, 201, 202, 203, + 204, 205, 206, -1, 208, 209, 210, 211, 212, 213, + 214, 215, 216, 217, -1, 219, -1, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, -1, -1, + 234, 235, 236, 237, -1, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, + 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, + 294, -1, -1, 297, 298, 299, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, -1, -1, -1, -1, 319, 320, 321, 322, 323, + 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, + 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, + 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, + 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, + 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, + 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, + 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, + 414, -1, -1, 417, 418, 419, 420, 421, 422, 423, + 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, + 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, + 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, + 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, + 464, -1, 466, 467, 468, 469, 470, 471, 472, 473, + 474, -1, -1, 477, -1, -1, 480, 481, 482, 483, + 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 499, 500, 501, -1, -1, + -1, -1, -1, -1, 508, 509, 510, -1, -1, -1, + -1, 515, -1, 517, -1, -1, -1, -1, 522, 523, + -1, 525, 526, 3, 4, 5, 6, 7, 8, 9, + 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, + -1, 31, 32, 33, -1, -1, -1, -1, -1, 39, + -1, -1, 42, 43, 44, -1, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, + -1, 81, -1, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, + -1, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, 117, 118, -1, + 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, + 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, + 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, -1, 163, 164, 165, 166, -1, 168, -1, + 170, 171, -1, 173, 174, 175, 176, 177, 178, -1, + 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, -1, + 200, 201, 202, 203, 204, 205, 206, -1, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, + -1, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, -1, -1, 234, 235, 236, 237, -1, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, 286, -1, 288, 289, + -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, -1, + 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, + 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, + 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, + 380, 381, -1, -1, 384, 385, 386, 387, 388, 389, + 390, 391, 392, -1, 394, 395, 396, 397, 398, -1, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, -1, -1, 417, 418, -1, + 420, 421, 422, 423, 424, 425, 426, -1, 428, 429, + 430, -1, -1, 433, 434, 435, 436, 437, 438, 439, + 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, + 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, + 460, 461, 462, 463, 464, -1, 466, 467, 468, 469, + 470, 471, 472, 473, 474, -1, -1, 477, -1, -1, + 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, + 500, 501, -1, -1, -1, -1, -1, -1, 508, 509, + 510, -1, -1, -1, -1, 515, -1, 517, -1, -1, + -1, -1, 522, 523, -1, 525, 526, 3, 4, 5, + 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, + -1, -1, -1, 39, -1, -1, 42, 43, 44, -1, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, -1, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, 81, -1, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, -1, 120, 121, 122, 123, 124, 125, + -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, + 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, 171, -1, 173, 174, 175, + 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, -1, -1, 234, 235, + 236, 237, -1, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, + -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, 394, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, -1, + 466, 467, 468, 469, 470, 471, 472, 473, 474, -1, + -1, 477, -1, -1, 480, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 501, -1, -1, -1, -1, + -1, -1, 508, 509, 510, -1, -1, -1, -1, 515, + -1, 517, -1, -1, -1, -1, 522, 523, -1, 525, + 526, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, + 32, 33, -1, -1, -1, -1, -1, 39, -1, -1, + 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, + -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, -1, 120, 121, + 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, + -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, + 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, + -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, + -1, 173, 174, 175, 176, 177, 178, -1, 180, -1, + 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, + 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + -1, -1, 234, 235, 236, 237, -1, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, + 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, + 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, + -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, + 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, -1, -1, 417, 418, -1, 420, 421, + 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, + -1, 433, 434, 435, 436, 437, 438, 439, 440, 441, + 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, + -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, + 462, 463, 464, -1, 466, 467, 468, 469, 470, 471, + 472, 473, 474, -1, -1, 477, -1, -1, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, + -1, -1, -1, -1, -1, -1, 508, 509, 510, -1, + -1, -1, -1, 515, -1, 517, -1, -1, -1, -1, + 522, 523, -1, 525, 526, 3, 4, 5, 6, 7, + 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, + 28, 29, -1, 31, 32, 33, -1, -1, -1, -1, + -1, 39, -1, -1, 42, 43, 44, -1, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + -1, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, -1, 75, 76, 77, + 78, 79, -1, 81, -1, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, -1, 94, 95, 96, 97, + 98, 99, -1, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, + 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, + 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, + 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 160, 161, -1, 163, 164, 165, 166, -1, + 168, -1, 170, 171, -1, 173, 174, 175, 176, 177, + 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + 198, -1, 200, 201, 202, 203, 204, 205, 206, -1, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + -1, 219, -1, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, -1, -1, 234, 235, 236, 237, + -1, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, -1, + 288, 289, -1, -1, 292, 293, 294, -1, -1, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, + -1, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, + 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, -1, 362, 363, 364, 365, 366, 367, + 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, + 378, 379, 380, 381, -1, -1, 384, 385, 386, 387, + 388, 389, 390, 391, 392, -1, 394, 395, 396, 397, + 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, + 408, 409, 410, 411, 412, 413, 414, -1, -1, 417, + 418, -1, 420, 421, 422, 423, 424, 425, 426, -1, + 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, + 438, 439, 440, 441, 442, 443, 444, 445, 446, -1, + -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, + 458, 459, 460, 461, 462, 463, 464, -1, 466, 467, + 468, 469, 470, 471, 472, 473, 474, -1, -1, 477, + -1, -1, 480, 481, 482, 483, 484, 485, 486, 487, + 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, + 498, 499, 500, 501, -1, -1, -1, -1, -1, -1, + 508, 509, 510, -1, -1, -1, -1, 515, -1, 517, + -1, -1, -1, -1, 522, 523, -1, 525, 526, 3, + 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, + 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, + -1, -1, -1, -1, -1, 39, -1, -1, 42, 43, + 44, -1, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, -1, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + -1, 75, 76, 77, 78, 79, -1, 81, -1, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, -1, + 94, 95, 96, 97, 98, 99, -1, 101, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, 117, 118, -1, 120, 121, 122, 123, + 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, + 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, + 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, 160, 161, -1, 163, + 164, 165, 166, -1, 168, -1, 170, 171, -1, 173, + 174, 175, 176, 177, 178, -1, 180, -1, 182, 183, + 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, + 194, 195, 196, 197, 198, -1, 200, 201, 202, 203, + 204, 205, 206, -1, 208, 209, 210, 211, 212, 213, + 214, 215, 216, 217, -1, 219, -1, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, -1, -1, + 234, 235, 236, 237, -1, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, + 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, + 294, -1, -1, 297, 298, 299, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, -1, -1, -1, -1, 319, 320, 321, 322, 323, + 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, + 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, + 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, + 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, + 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, + 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, + 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, + 414, -1, -1, 417, 418, -1, 420, 421, 422, 423, + 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, + 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, + 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, + 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, + 464, -1, 466, 467, 468, 469, 470, 471, 472, 473, + 474, -1, -1, 477, -1, -1, 480, 481, 482, 483, + 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 499, 500, 501, -1, -1, + -1, -1, -1, -1, 508, 509, 510, -1, -1, -1, + -1, 515, -1, 517, -1, -1, -1, -1, 522, 523, + -1, 525, 526, 3, 4, 5, 6, 7, 8, 9, + 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, + -1, 31, 32, 33, -1, -1, -1, -1, -1, 39, + -1, -1, 42, 43, 44, -1, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, + -1, 81, -1, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, + -1, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, 117, 118, -1, + 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, + 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, + 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, -1, 163, 164, 165, 166, -1, 168, -1, + 170, 171, -1, 173, 174, 175, 176, 177, 178, -1, + 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, -1, + 200, 201, 202, 203, 204, 205, 206, -1, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, + -1, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, -1, -1, 234, 235, 236, 237, -1, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, 286, -1, 288, 289, + -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, -1, + 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, + 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, + 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, + 380, 381, -1, -1, 384, 385, 386, 387, 388, 389, + 390, 391, 392, -1, 394, 395, 396, 397, 398, -1, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, -1, -1, 417, 418, -1, + 420, 421, 422, 423, 424, 425, 426, -1, 428, 429, + 430, -1, -1, 433, 434, 435, 436, 437, 438, 439, + 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, + 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, + 460, 461, 462, 463, 464, -1, 466, 467, 468, 469, + 470, 471, 472, 473, 474, -1, -1, 477, -1, -1, + 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, + 500, 501, -1, -1, -1, -1, -1, -1, 508, 509, + 510, -1, -1, -1, -1, 515, -1, 517, -1, -1, + -1, -1, 522, 523, -1, 525, 526, 3, 4, 5, + 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, + -1, -1, -1, 39, -1, -1, 42, 43, 44, -1, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, -1, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, 81, -1, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, -1, 120, 121, 122, 123, 124, 125, + -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, + 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, 171, -1, 173, 174, 175, + 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, -1, -1, 234, 235, + 236, 237, -1, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, + -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, 394, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, -1, + 466, 467, 468, 469, 470, 471, 472, 473, 474, -1, + -1, 477, -1, -1, 480, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 501, -1, -1, -1, -1, + -1, -1, 508, 509, 510, -1, -1, -1, -1, 515, + -1, 517, -1, -1, -1, -1, 522, 523, -1, 525, + 526, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 3, -1, -1, 501, -1, - -1, 504, 505, 506, -1, 508, 509, 510, 511, 512, - 513, -1, -1, 516, 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, + 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, + 32, 33, -1, -1, -1, -1, -1, 39, -1, -1, + 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, + -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, -1, 120, 121, + 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, + -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, + 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, + -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, + -1, 173, 174, 175, 176, 177, 178, -1, 180, -1, + 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, + 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + -1, -1, 234, 235, 236, 237, -1, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, + 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, + 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, + -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, + 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, -1, -1, 417, 418, -1, 420, 421, + 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, + -1, 433, 434, 435, 436, 437, 438, 439, 440, 441, + 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, + -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, + 462, 463, 464, -1, 466, 467, 468, 469, 470, 471, + 472, 473, 474, -1, -1, 477, -1, -1, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, + -1, -1, -1, -1, -1, -1, 508, 509, 510, -1, + -1, -1, -1, 515, -1, 517, -1, -1, -1, -1, + 522, 523, -1, 525, 526, 3, 4, 5, 6, 7, + 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, + 28, 29, -1, 31, 32, 33, -1, -1, -1, -1, + -1, 39, -1, -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, - 68, 69, 70, 71, 72, 73, 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, + -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, 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, + 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, + 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, + 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, - 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, - 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 158, 159, 160, 161, -1, 163, 164, 165, 166, -1, + 168, -1, 170, 171, -1, 173, 174, 175, 176, 177, + 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 198, -1, 200, 201, 202, 203, 204, 205, 206, -1, 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, + -1, 219, -1, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, -1, -1, 234, 235, 236, 237, + -1, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, + 278, 279, 280, 281, 282, 283, 284, 285, 286, -1, + 288, 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 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, + 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, + -1, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, + 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, + 358, 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, - 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, - 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, - 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, - 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, - 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, - 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, - 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, + 378, 379, 380, 381, -1, -1, 384, 385, 386, 387, + 388, 389, 390, 391, 392, -1, 394, 395, 396, 397, + 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, + 408, 409, 410, 411, 412, 413, 414, -1, -1, 417, + 418, -1, 420, 421, 422, 423, 424, 425, 426, -1, + 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, + 438, 439, 440, 441, 442, 443, 444, 445, 446, -1, + -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, + 458, 459, 460, 461, 462, 463, 464, -1, 466, 467, + 468, 469, 470, 471, 472, 473, 474, -1, -1, 477, + -1, -1, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 498, 499, 500, 3, -1, -1, -1, -1, -1, -1, - -1, -1, 510, -1, -1, -1, -1, -1, -1, -1, + 498, 499, 500, 501, -1, -1, -1, -1, -1, -1, + 508, 509, 510, -1, -1, -1, -1, 515, -1, 517, + -1, -1, -1, -1, 522, 523, -1, 525, 526, 3, + 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, + 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, + -1, -1, -1, -1, -1, 39, -1, -1, 42, 43, + 44, -1, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, -1, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + -1, 75, 76, 77, 78, 79, -1, 81, -1, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, -1, + 94, 95, 96, 97, 98, 99, -1, 101, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, + 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, + 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, + 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, 160, 161, -1, 163, + 164, 165, 166, -1, 168, -1, 170, 171, -1, 173, + 174, 175, 176, 177, 178, -1, 180, -1, 182, 183, + 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, + 194, 195, 196, 197, 198, -1, 200, 201, 202, 203, + 204, 205, 206, -1, 208, 209, 210, 211, 212, 213, + 214, 215, 216, 217, -1, 219, -1, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, -1, -1, + 234, 235, 236, 237, -1, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, + 274, -1, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, + 294, -1, -1, 297, 298, 299, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, -1, -1, -1, -1, 319, 320, 321, 322, 323, + 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, + 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, + 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, + 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, + 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, + 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, + 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, + 414, -1, -1, 417, 418, -1, 420, 421, 422, 423, + 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, + 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, + 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, + 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, + 464, -1, 466, 467, 468, 469, 470, 471, 472, 473, + 474, -1, -1, 477, -1, -1, 480, 481, 482, 483, + 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 499, 500, -1, -1, -1, + -1, -1, -1, -1, 508, 509, -1, -1, -1, -1, + -1, 515, -1, 517, -1, -1, -1, -1, 522, 523, + -1, 525, 526, 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, -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, + -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, -1, -1, 83, 84, 85, 86, 87, 88, -1, + -1, 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, - -1, -1, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, + -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, - -1, 161, -1, 163, 164, 165, 166, -1, 168, -1, - 170, -1, -1, -1, 174, 175, 176, -1, 178, -1, + 160, 161, -1, 163, 164, 165, 166, -1, 168, -1, + 170, 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, - 190, 191, 192, 193, -1, 195, 196, 197, 198, -1, - 200, 201, 202, 203, 204, 205, 206, -1, 208, -1, + 190, 191, 192, 193, 194, 195, 196, 197, 198, -1, + 200, 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, - -1, 221, -1, -1, 224, -1, 226, 227, 228, 229, - 230, 231, -1, -1, 234, -1, 236, -1, -1, 239, + -1, 221, -1, -1, 224, 225, 226, 227, 228, 229, + 230, 231, -1, -1, 234, 235, 236, 237, -1, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, -1, + 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, -1, 276, 277, -1, 279, - -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, + 280, 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, - -1, 301, -1, 303, 304, 305, 306, 307, 308, 309, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, - 320, 321, -1, 323, 324, 325, 326, 327, 328, -1, + 320, 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, -1, 362, 363, -1, 365, 366, 367, 368, 369, + 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, 387, 388, 389, - 390, 391, 392, -1, -1, 395, 396, 397, 398, -1, + 390, 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, -1, - 420, -1, 422, 423, 424, 425, 426, -1, 428, 429, - 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, + 420, 421, 422, 423, 424, 425, 426, -1, 428, 429, + 430, -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, - 460, 461, 462, 463, 464, -1, 466, -1, 468, 469, + 460, 461, 462, 463, 464, -1, 466, 467, 468, 469, 470, 471, 472, 473, 474, -1, -1, 477, -1, -1, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, - 500, 3, -1, -1, -1, -1, -1, -1, -1, -1, - 510, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 500, 501, -1, -1, -1, -1, -1, -1, 508, 509, + 510, -1, -1, -1, -1, 515, -1, 517, -1, -1, + -1, -1, 522, 523, -1, 525, 526, 3, 4, 5, + 6, 7, -1, 9, 10, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, + -1, -1, -1, 39, -1, -1, 42, 43, 44, -1, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, -1, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, 81, -1, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, + -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, + 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, 171, -1, 173, 174, 175, + 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, -1, -1, 234, 235, + 236, 237, -1, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, -1, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, + -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, 394, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, -1, + 466, 467, 468, 469, 470, 471, 472, 473, 474, -1, + -1, 477, -1, -1, 480, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, -1, -1, -1, -1, -1, + -1, -1, 508, 509, -1, -1, -1, -1, -1, 515, + -1, 517, -1, -1, -1, -1, 522, 523, -1, 525, + 526, 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, -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, + 32, 33, -1, -1, -1, -1, -1, 39, -1, -1, + 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, + -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, -1, 161, - -1, 163, 164, 165, 166, -1, 168, -1, 170, -1, - -1, -1, 174, 175, 176, -1, 178, -1, 180, -1, + 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, + -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, + -1, 173, 174, 175, 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, - 192, 193, -1, 195, 196, 197, 198, -1, 200, 201, - 202, 203, 204, 205, 206, -1, 208, -1, 210, 211, + 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, + 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, - -1, -1, 224, -1, 226, 227, 228, 229, 230, 231, - -1, -1, 234, -1, 236, -1, -1, 239, 240, 241, + -1, 223, 224, 225, 226, 227, 228, 229, 230, 231, + -1, -1, 234, 235, 236, 237, -1, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, - 262, 263, 264, 265, 266, 267, 268, -1, 270, 271, - 272, 273, 274, -1, 276, 277, -1, 279, -1, 281, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, -1, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, - 292, 293, 294, -1, -1, 297, 298, 299, -1, 301, - -1, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, - -1, 323, 324, 325, 326, 327, 328, -1, 330, 331, + 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, - 362, 363, -1, 365, 366, 367, 368, 369, 370, 371, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, - 392, -1, -1, 395, 396, 397, 398, -1, 400, 401, + 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, -1, -1, 417, 418, -1, 420, -1, + 412, 413, 414, -1, -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, - -1, 433, 434, 435, 436, 437, -1, 439, 440, 441, + -1, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, - 462, 463, 464, -1, 466, -1, 468, 469, 470, 471, + 462, 463, 464, -1, 466, 467, 468, 469, 470, 471, 472, 473, 474, -1, -1, 477, -1, -1, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 498, 499, 500, 3, - 4, 5, -1, -1, -1, 9, -1, -1, 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, 37, -1, -1, -1, -1, 42, 43, - 44, -1, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, -1, 59, 60, 61, 62, 63, - 64, -1, -1, 67, 68, 69, 70, 71, 72, 73, - -1, 75, 76, 77, 78, 79, -1, 81, -1, 83, - 84, 85, 86, 87, 88, 89, 90, 91, 92, -1, - 94, 95, 96, 97, 98, 99, -1, 101, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, - 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, - 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, - 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, 160, 161, -1, 163, - 164, 165, 166, -1, 168, -1, 170, 171, -1, 173, - 174, 175, 176, 177, 178, -1, 180, -1, 182, 183, - 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, - 194, 195, 196, 197, 198, -1, 200, 201, 202, 203, - 204, 205, 206, -1, 208, 209, 210, 211, 212, 213, - 214, 215, 216, 217, -1, 219, -1, 221, 222, 223, - 224, 225, 226, 227, 228, 229, 230, 231, -1, -1, - 234, 235, 236, 237, -1, 239, 240, 241, 242, 243, - 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, - 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, - 274, -1, 276, 277, 278, 279, -1, 281, 282, 283, - 284, 285, 286, -1, 288, 289, 290, -1, 292, 293, - 294, -1, -1, 297, 298, 299, 300, 301, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, -1, -1, -1, -1, 319, 320, 321, 322, 323, - 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, - 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, - 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, - 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, - 374, 375, 376, 377, 378, 379, 380, 381, -1, 383, - 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, - 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, -1, -1, 417, 418, -1, 420, 421, 422, 423, - 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, - 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, - 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, - 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, - 464, -1, 466, 467, 468, 469, 470, 471, 472, 473, - 474, -1, -1, 477, -1, -1, 480, 481, 482, 483, - 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, - 494, 495, 496, 497, 498, 499, 500, -1, -1, 8, - -1, -1, 11, -1, 508, 509, 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, 40, - 80, -1, -1, -1, -1, 46, -1, -1, -1, -1, - -1, -1, 53, -1, -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, 80, - -1, -1, -1, -1, 36, -1, -1, -1, 167, -1, - -1, -1, -1, 172, 46, -1, -1, -1, 177, -1, - -1, 53, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 194, -1, -1, -1, -1, - 199, -1, -1, -1, -1, -1, 166, -1, 80, -1, - -1, -1, -1, -1, -1, -1, -1, 177, -1, -1, - -1, -1, -1, 222, 223, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 194, -1, -1, -1, 237, 199, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 177, -1, -1, -1, - -1, -1, 222, 223, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 194, -1, -1, 275, 237, 199, 278, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 292, -1, -1, 295, -1, -1, -1, - -1, 222, 223, -1, -1, 177, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 275, 237, -1, 278, -1, - -1, -1, 194, -1, -1, -1, -1, 199, -1, -1, - -1, -1, 292, -1, -1, 295, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 222, 223, -1, -1, 275, -1, -1, 278, -1, -1, - -1, -1, -1, -1, 324, 237, -1, -1, -1, -1, - -1, 292, -1, -1, 295, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 394, -1, -1, -1, -1, - -1, -1, -1, 275, -1, -1, 278, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 292, -1, -1, 295, -1, -1, -1, -1, -1, 8, - -1, -1, 11, -1, 394, -1, 15, 16, 17, 18, - 19, 20, 21, -1, -1, -1, 318, -1, -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, 394, 53, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 80, 501, -1, -1, 504, 505, 506, -1, 508, - 509, 510, 511, 512, 513, -1, -1, -1, -1, -1, - -1, -1, 394, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 501, -1, -1, 504, 505, 506, -1, 508, 509, - 510, 511, 512, 513, -1, -1, -1, -1, 8, -1, - -1, 11, -1, -1, -1, 15, 16, 17, 18, 19, - 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, - 501, -1, -1, 504, 505, 506, 36, 508, 509, 510, - 511, 512, 513, -1, -1, -1, 46, -1, 177, -1, - -1, -1, -1, 53, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 194, -1, -1, -1, -1, - 199, -1, -1, -1, -1, -1, -1, -1, -1, 501, - 80, -1, 504, 505, 506, -1, 508, 509, 510, 511, - 512, 513, -1, 222, 223, -1, -1, -1, -1, -1, - -1, -1, -1, 8, -1, -1, 11, -1, 237, -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, 40, -1, -1, -1, -1, - -1, 46, -1, -1, -1, -1, 275, -1, 53, 278, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 292, -1, -1, 295, -1, -1, -1, - -1, -1, 172, -1, -1, 80, -1, 177, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 194, -1, -1, -1, -1, 199, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 222, 223, -1, -1, -1, -1, -1, -1, - -1, -1, 8, -1, -1, 11, -1, 237, -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, 394, -1, -1, -1, -1, - 46, -1, 177, -1, -1, 275, -1, 53, 278, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 194, - -1, -1, 292, -1, 199, 295, -1, -1, -1, -1, - -1, -1, -1, -1, 80, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 222, 223, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 237, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 275, -1, 501, 278, -1, 504, 505, 506, -1, 508, - 509, 510, 511, 512, 513, -1, -1, 292, -1, -1, - 295, 167, -1, -1, 394, -1, 8, -1, -1, 11, - -1, 177, -1, 15, 16, 17, 18, 19, 20, 21, - -1, -1, -1, -1, -1, -1, -1, -1, 194, -1, - -1, -1, -1, 199, 36, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 46, -1, -1, -1, -1, -1, - -1, 53, -1, -1, -1, -1, 222, 223, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 237, -1, -1, -1, -1, -1, -1, 80, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 394, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 275, - -1, 501, 278, -1, 504, 505, 506, -1, 508, 509, - 510, 511, 512, 513, -1, -1, 292, -1, -1, 295, - -1, -1, -1, -1, -1, 8, -1, -1, 11, -1, - -1, -1, 15, 16, 17, 18, 19, 20, 21, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 36, -1, -1, -1, 40, -1, -1, - -1, -1, -1, 46, -1, 177, -1, -1, -1, -1, - 53, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 194, -1, -1, -1, -1, 199, -1, -1, - -1, -1, -1, -1, -1, -1, 501, 80, -1, 504, - 505, 506, -1, 508, 509, 510, 511, 512, 513, -1, - 222, 223, -1, -1, -1, -1, -1, -1, 394, -1, - 8, -1, -1, 11, -1, 237, -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, 275, -1, 53, 278, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 292, -1, -1, 295, -1, -1, -1, -1, -1, -1, - -1, -1, 80, -1, 177, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 194, -1, -1, -1, -1, 199, -1, -1, -1, - -1, -1, -1, -1, -1, 501, -1, -1, 504, 505, - 506, -1, 508, 509, 510, 511, 512, 513, -1, 222, - 223, -1, -1, -1, -1, -1, -1, -1, -1, 8, - -1, -1, 11, -1, 237, -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, 394, -1, -1, -1, -1, 46, -1, 177, - -1, -1, 275, -1, 53, 278, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 194, -1, -1, 292, - -1, 199, 295, -1, -1, 427, -1, -1, -1, -1, - -1, 80, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 222, 223, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 237, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 275, -1, 501, - 278, -1, 504, 505, 506, -1, 508, 509, 510, 511, - 512, 513, -1, -1, 292, -1, -1, 295, -1, -1, - -1, 394, -1, 8, -1, -1, 11, -1, 177, -1, - 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, - -1, -1, -1, -1, -1, 194, -1, -1, -1, -1, - 199, 36, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 46, -1, -1, -1, -1, -1, -1, 53, -1, - -1, -1, -1, 222, 223, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 237, -1, - -1, -1, -1, -1, -1, 80, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 8, -1, -1, 11, - -1, -1, -1, 15, 16, -1, 394, 19, 20, 21, - -1, -1, -1, -1, -1, -1, 275, -1, 501, 278, - -1, 504, 505, 506, 36, 508, 509, 510, 511, 512, - 513, -1, -1, 292, 46, -1, 295, -1, -1, -1, - -1, 53, -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, 80, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 46, 177, -1, -1, -1, -1, -1, 53, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 194, - -1, -1, -1, -1, 199, -1, -1, -1, -1, -1, - -1, -1, -1, 501, -1, 80, 504, 505, 506, -1, - 508, 509, 510, 511, 512, 513, -1, 222, 223, -1, - -1, -1, -1, -1, -1, 394, -1, -1, -1, -1, - -1, -1, 237, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 177, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 275, -1, 194, 278, -1, -1, -1, 199, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 292, -1, -1, - 295, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 222, 223, 177, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 237, -1, -1, -1, 194, - -1, -1, -1, -1, 199, -1, -1, -1, -1, -1, - -1, -1, 501, -1, -1, 504, 505, 506, -1, 508, - 509, 510, 511, 512, 513, -1, -1, 222, 223, -1, - -1, -1, -1, 275, -1, -1, 278, -1, -1, -1, - -1, -1, 237, -1, -1, -1, -1, -1, -1, -1, - 292, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 394, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 278, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 292, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 394, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 501, -1, -1, 504, - 505, 506, -1, 508, 509, 510, 511, 512, 513, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 394, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 492, 493, 494, 495, 496, 497, 498, 499, 500, -1, + -1, -1, -1, -1, -1, -1, 508, 509, -1, -1, + -1, -1, -1, 515, -1, 517, -1, -1, -1, -1, + 522, 523, -1, 525, 526, 3, 4, 5, 6, 7, + -1, 9, 10, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, + 28, 29, -1, 31, 32, 33, -1, -1, -1, -1, + -1, 39, -1, -1, 42, 43, 44, -1, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + -1, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, -1, 75, 76, 77, + 78, 79, -1, 81, -1, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, -1, 94, 95, 96, 97, + 98, 99, -1, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, + 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, + 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, + 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 160, 161, -1, 163, 164, 165, 166, -1, + 168, -1, 170, 171, -1, 173, 174, 175, 176, 177, + 178, -1, 180, 181, 182, 183, 184, 185, -1, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + 198, 199, 200, 201, 202, 203, 204, 205, 206, -1, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + -1, 219, -1, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, -1, -1, 234, 235, 236, 237, + -1, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, -1, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, -1, + 288, 289, -1, -1, 292, 293, 294, -1, -1, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, + -1, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, + 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, -1, 362, 363, 364, 365, 366, 367, + 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, + 378, 379, 380, 381, -1, -1, 384, 385, 386, 387, + 388, 389, 390, 391, 392, -1, 394, 395, 396, 397, + 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, + 408, 409, 410, 411, 412, 413, 414, -1, -1, 417, + 418, -1, 420, 421, 422, 423, 424, 425, 426, -1, + 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, + 438, 439, 440, 441, 442, 443, 444, 445, 446, -1, + -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, + 458, 459, 460, 461, 462, 463, 464, -1, 466, 467, + 468, 469, 470, 471, 472, 473, 474, -1, -1, 477, + -1, -1, 480, 481, 482, 483, 484, 485, 486, 487, + 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, + 498, 499, 500, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 515, -1, 517, + -1, -1, -1, -1, 522, 523, -1, 525, 526, 3, + 4, 5, 6, 7, -1, 9, 10, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, + 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, + -1, -1, -1, -1, -1, 39, -1, -1, 42, 43, + 44, -1, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, -1, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + -1, 75, 76, 77, 78, 79, -1, 81, -1, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, -1, + 94, 95, 96, 97, 98, 99, -1, 101, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, + 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, + 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, + 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, 160, 161, -1, 163, + 164, 165, 166, -1, 168, -1, 170, 171, -1, 173, + 174, 175, 176, 177, 178, -1, 180, -1, 182, 183, + 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, + 194, 195, 196, 197, 198, -1, 200, 201, 202, 203, + 204, 205, 206, -1, 208, 209, 210, 211, 212, 213, + 214, 215, 216, 217, -1, 219, -1, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, -1, -1, + 234, 235, 236, 237, -1, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, + 274, -1, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, + 294, -1, -1, 297, 298, 299, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, -1, -1, -1, -1, 319, 320, 321, 322, 323, + 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, + 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, + 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, + 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, + 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, + 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, + 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, + 414, -1, -1, 417, 418, -1, 420, 421, 422, 423, + 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, + 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, + 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, + 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, + 464, -1, 466, 467, 468, 469, 470, 471, 472, 473, + 474, -1, -1, 477, -1, -1, 480, 481, 482, 483, + 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 499, 500, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 501, - -1, -1, 504, 505, 506, -1, 508, 509, 510, 511, - 512, 513, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 515, -1, 517, -1, -1, -1, -1, 522, 523, + -1, 525, 526, 3, 4, 5, 6, 7, -1, 9, + 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, + -1, 31, 32, 33, -1, -1, -1, -1, -1, 39, + -1, -1, 42, 43, 44, -1, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, + -1, 81, -1, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, + -1, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, + 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, + 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, + 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, -1, 163, 164, 165, 166, -1, 168, -1, + 170, 171, -1, 173, 174, 175, 176, 177, 178, -1, + 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, -1, + 200, 201, 202, 203, 204, 205, 206, -1, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, + -1, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, -1, -1, 234, 235, 236, 237, -1, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, -1, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, 286, -1, 288, 289, + -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, -1, + 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, + 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, + 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, + 380, 381, -1, -1, 384, 385, 386, 387, 388, 389, + 390, 391, 392, -1, 394, 395, 396, 397, 398, -1, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, -1, -1, 417, 418, -1, + 420, 421, 422, 423, 424, 425, 426, -1, 428, 429, + 430, -1, -1, 433, 434, 435, 436, 437, 438, 439, + 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, + 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, + 460, 461, 462, 463, 464, -1, 466, 467, 468, 469, + 470, 471, 472, 473, 474, -1, -1, 477, -1, -1, + 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, + 500, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 515, -1, 517, -1, -1, + -1, -1, 522, 523, -1, 525, 526, 3, 4, 5, + 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, + -1, -1, -1, 39, -1, -1, 42, 43, 44, -1, + 46, 47, 48, 49, 50, 51, 52, -1, 54, 55, + 56, 57, -1, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, 81, -1, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, -1, 120, 121, 122, 123, 124, 125, + -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, -1, + 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, 171, -1, 173, 174, 175, + 176, -1, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, -1, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, -1, -1, 224, 225, + 226, 227, 228, 229, 230, 231, -1, -1, 234, 235, + 236, -1, -1, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, -1, + 276, 277, -1, 279, 280, 281, 282, 283, 284, 285, + 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, + -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, -1, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, -1, + 466, 467, 468, 469, 470, 471, 472, 473, 474, -1, + -1, 477, -1, -1, 480, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, -1, -1, -1, -1, -1, + -1, -1, 508, 509, 510, -1, 3, 4, 5, 515, + -1, 517, 9, -1, -1, -1, 522, 523, -1, 525, + 526, -1, -1, -1, -1, 22, 23, 24, 25, 26, + 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, + 37, -1, -1, -1, -1, 42, 43, 44, -1, 46, + 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, + 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, + 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, + 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, + 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, + -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, + -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, + 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, + -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, + 157, 158, 159, 160, 161, -1, 163, 164, 165, 166, + -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, + 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, + 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, + 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, + -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, + 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, + 237, -1, 239, 240, 241, 242, 243, 244, 245, 246, + 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, + 267, 268, 269, 270, 271, 272, 273, 274, -1, 276, + 277, 278, 279, -1, 281, 282, 283, 284, 285, 286, + -1, 288, 289, 290, -1, 292, 293, 294, -1, -1, + 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, + -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, + 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, + 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, + -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, 379, 380, 381, -1, 383, 384, 385, 386, + 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, + 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, + 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, + -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, + 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, + -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, + -1, 458, 459, 460, 461, 462, 463, 464, -1, 466, + 467, 468, 469, 470, 471, 472, 473, 474, -1, -1, + 477, -1, -1, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 498, 499, 500, -1, -1, -1, -1, 3, -1, + -1, 508, 509, 510, -1, -1, -1, -1, 515, -1, + 517, -1, -1, -1, -1, -1, 523, 22, 23, 24, + 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, + -1, -1, -1, -1, -1, 40, -1, -1, 43, 44, + -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, + -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, + -1, -1, 67, 68, 69, 70, 71, 72, 73, -1, + 75, 76, 77, 78, 79, -1, -1, -1, 83, 84, + 85, 86, 87, 88, -1, 90, 91, 92, -1, 94, + 95, 96, 97, 98, 99, -1, -1, 102, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, + 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, + 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, + 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, + 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, -1, 161, 162, 163, 164, + 165, 166, 167, 168, -1, 170, -1, -1, -1, 174, + 175, 176, -1, 178, -1, 180, -1, 182, 183, 184, + 185, -1, 187, 188, 189, 190, 191, 192, 193, -1, + 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, + 205, 206, -1, 208, -1, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, -1, 221, -1, -1, 224, + -1, 226, 227, 228, 229, 230, 231, -1, -1, 234, + -1, 236, -1, 238, 239, 240, 241, 242, 243, 244, + 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, -1, 270, 271, 272, 273, 274, + -1, 276, 277, -1, 279, -1, 281, 282, 283, 284, + 285, 286, 287, 288, 289, -1, -1, 292, 293, 294, + -1, 296, 297, 298, 299, -1, 301, -1, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + -1, -1, -1, -1, 319, 320, 321, -1, 323, 324, + 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, + 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, + 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, -1, 362, 363, -1, + 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, + 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, + 385, 386, 387, 388, 389, 390, 391, 392, -1, -1, + 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + -1, -1, 417, 418, -1, 420, -1, 422, 423, 424, + 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, + 435, 436, 437, -1, 439, 440, 441, 442, 443, 444, + 445, 446, 447, -1, 449, 450, 451, -1, 453, 454, + 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, + -1, 466, -1, 468, 469, 470, 471, 472, 473, 474, + -1, -1, 477, -1, -1, 480, 481, 482, 483, 484, + 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, + 495, 496, 497, 498, 499, 500, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 518, -1, 22, 23, 24, 25, 26, + 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, + 47, 48, -1, 50, 51, 52, 53, 54, -1, 56, + 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, + 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, + 77, 78, 79, -1, -1, -1, 83, 84, 85, 86, + 87, 88, -1, 90, 91, 92, -1, 94, 95, 96, + 97, 98, 99, -1, -1, 102, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, + -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, + -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, + 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, + -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, + 157, 158, 159, -1, 161, -1, 163, 164, 165, 166, + -1, 168, -1, 170, -1, -1, -1, 174, 175, 176, + -1, 178, -1, 180, -1, 182, 183, 184, 185, -1, + 187, 188, 189, 190, 191, 192, 193, -1, 195, 196, + 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, + -1, 208, -1, 210, 211, 212, 213, 214, 215, 216, + 217, -1, 219, -1, 221, -1, -1, 224, -1, 226, + 227, 228, 229, 230, 231, -1, -1, 234, -1, 236, + -1, -1, 239, 240, 241, 242, 243, 244, 245, 246, + 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, + 267, 268, -1, 270, 271, 272, 273, 274, -1, 276, + 277, -1, 279, -1, 281, 282, 283, 284, 285, 286, + -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, + 297, 298, 299, -1, 301, -1, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, + -1, -1, 319, 320, 321, -1, 323, 324, 325, 326, + 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, + 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, + -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 360, -1, 362, 363, -1, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, + 387, 388, 389, 390, 391, 392, -1, -1, 395, 396, + 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, + 417, 418, -1, 420, -1, 422, 423, 424, 425, 426, + -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, + 437, -1, 439, 440, 441, 442, 443, 444, 445, 446, + -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, + -1, 458, 459, 460, 461, 462, 463, 464, -1, 466, + -1, 468, 469, 470, 471, 472, 473, 474, -1, -1, + 477, -1, -1, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 498, 499, 500, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 3, -1, 5, -1, -1, -1, 501, -1, -1, 504, - 505, 506, -1, 508, 509, 510, 511, 512, 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, + 517, 518, -1, 22, 23, 24, 25, 26, 27, 28, + 29, -1, 31, 32, 33, 34, 35, -1, 37, -1, + -1, -1, -1, 42, 43, 44, -1, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, -1, + 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, + 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, + 79, -1, 81, -1, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, -1, 94, 95, 96, 97, 98, + 99, -1, 101, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, + -1, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, + -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, + 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, -1, 161, -1, 163, 164, 165, 166, -1, 168, + -1, 170, 171, 172, 173, 174, 175, 176, 177, 178, + -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, -1, + 219, -1, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, -1, -1, 234, 235, 236, 237, -1, + 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, 274, -1, 276, 277, 278, + 279, -1, 281, 282, 283, 284, 285, 286, -1, 288, + 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, -1, + 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, + -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, + 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, + 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, + 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, + 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, + 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, + -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, + 409, 410, 411, 412, 413, 414, 415, -1, 417, 418, + 419, 420, 421, 422, 423, 424, 425, 426, -1, 428, + 429, 430, -1, -1, 433, 434, 435, 436, 437, -1, + 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, + 449, 450, 451, 452, 453, 454, 455, 456, -1, 458, + 459, 460, 461, 462, 463, 464, -1, 466, 467, 468, + 469, 470, 471, 472, 473, 474, -1, -1, 477, -1, + 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, + 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, + 499, 500, -1, 3, 503, 5, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 517, -1, + -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, + -1, 31, 32, 33, -1, -1, -1, -1, -1, -1, + -1, -1, 42, 43, 44, -1, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, + 60, 61, 62, 63, 64, -1, 66, 67, 68, 69, + 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, + -1, 81, -1, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, + -1, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, + 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, + 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, + 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + -1, 161, -1, 163, 164, 165, 166, -1, 168, -1, + 170, 171, 172, 173, 174, 175, 176, 177, 178, -1, + 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, -1, + 200, 201, 202, 203, 204, 205, 206, -1, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, + -1, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, 232, -1, 234, 235, 236, 237, -1, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, -1, 276, 277, 278, 279, + -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, + -1, 291, 292, 293, 294, -1, -1, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, -1, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, -1, + 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, + 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, + 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, + 380, 381, 382, -1, 384, 385, 386, 387, 388, 389, + 390, 391, 392, 393, 394, 395, 396, 397, 398, -1, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, -1, 417, 418, 419, + 420, 421, 422, 423, 424, 425, 426, -1, 428, 429, + 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, + 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, + 450, 451, 452, 453, 454, 455, 456, -1, 458, 459, + 460, 461, 462, 463, 464, -1, 466, 467, 468, 469, + 470, 471, 472, 473, 474, -1, -1, 477, -1, 479, + 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, + 500, -1, 3, 503, 5, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 517, -1, -1, + -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, + 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, + -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, + 61, 62, 63, 64, -1, 66, 67, 68, 69, 70, + 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, + 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, + 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, + 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, + 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, -1, + 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, + 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, + -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, 232, -1, 234, 235, 236, 237, -1, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, + 271, 272, 273, 274, -1, 276, 277, 278, 279, -1, + 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, + 291, 292, 293, 294, -1, -1, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, + 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, + 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, 435, 436, 437, -1, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, 463, 464, -1, 466, 467, 468, 469, 470, + 471, 472, 473, 474, -1, -1, 477, -1, -1, 480, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 517, -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, - 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, + -1, 94, 95, 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, - 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, - 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, - 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, - 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, - 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, - 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, - 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, - 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, + 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, + 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, + -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, + -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, + 153, 154, 155, 156, 157, 158, 159, -1, 161, -1, + 163, 164, 165, 166, -1, 168, -1, 170, 171, -1, + 173, 174, 175, 176, 177, 178, -1, 180, -1, 182, + 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, + 193, 194, 195, 196, 197, 198, -1, 200, 201, 202, + 203, 204, 205, 206, -1, 208, 209, 210, 211, 212, + 213, 214, 215, 216, 217, -1, 219, -1, 221, 222, + 223, 224, 225, 226, 227, 228, 229, 230, 231, -1, + -1, 234, 235, 236, 237, -1, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 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, + 273, 274, -1, 276, 277, 278, 279, -1, 281, 282, + 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, + 293, 294, -1, -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, - 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, + 313, 314, -1, -1, -1, -1, 319, 320, 321, 322, + 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, + 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, + 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, - 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, + 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, + -1, 384, 385, 386, 387, 388, 389, 390, 391, 392, + -1, 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 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, + 413, 414, -1, -1, 417, 418, -1, 420, 421, 422, + 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, + 433, 434, 435, 436, 437, -1, 439, 440, 441, 442, + 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, + 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, + 463, 464, -1, 466, 467, 468, 469, 470, 471, 472, + 473, 474, -1, -1, 477, -1, -1, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 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, + -1, -1, -1, -1, 517, -1, -1, 22, 23, 24, + 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, + -1, -1, -1, -1, -1, -1, -1, 42, 43, 44, + -1, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, -1, 59, 60, 61, 62, 63, 64, + -1, 66, 67, 68, 69, 70, 71, 72, 73, -1, + 75, 76, 77, 78, 79, -1, 81, -1, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, -1, 94, + 95, 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, - 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, - 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, - 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, + 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, + 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, + 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, + 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, -1, 161, -1, 163, 164, + 165, 166, -1, 168, -1, 170, 171, -1, 173, 174, + 175, 176, 177, 178, -1, 180, -1, 182, 183, 184, + 185, -1, 187, 188, 189, 190, 191, 192, 193, 194, + 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, + 205, 206, -1, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, -1, 219, -1, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, -1, -1, 234, + 235, 236, 237, -1, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, + -1, 276, 277, 278, 279, -1, 281, 282, 283, 284, + 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, + -1, -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, - 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, - 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, 361, 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, + -1, -1, -1, -1, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, + 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, + 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, -1, 362, 363, 364, + 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, + 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, + 385, 386, 387, 388, 389, 390, 391, 392, -1, 394, + 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, - 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, - 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, - 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, - 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, - 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, - 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, + -1, -1, 417, 418, -1, 420, 421, 422, 423, 424, + 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, + 435, 436, 437, -1, 439, 440, 441, 442, 443, 444, + 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, + 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, + -1, 466, 467, 468, 469, 470, 471, 472, 473, 474, + -1, -1, 477, -1, -1, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 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, + -1, -1, 517, -1, -1, 22, 23, 24, 25, 26, + 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, + 47, 48, -1, 50, 51, 52, 53, 54, -1, 56, + 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, + 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, + 77, 78, 79, -1, -1, -1, 83, 84, 85, 86, + 87, 88, -1, 90, 91, 92, -1, 94, 95, 96, + 97, 98, 99, -1, -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, - 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, + -1, 118, -1, 120, 121, 122, 123, 124, 125, 126, + 127, 128, 129, 130, 131, -1, -1, 134, 135, 136, + 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, + -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, + 157, 158, 159, -1, 161, -1, 163, 164, 165, 166, + -1, 168, -1, 170, -1, 172, -1, 174, 175, 176, + -1, 178, -1, 180, -1, 182, 183, 184, 185, -1, + 187, 188, 189, 190, 191, 192, 193, -1, 195, 196, + 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, + -1, 208, -1, 210, 211, 212, 213, 214, 215, 216, + 217, -1, 219, -1, 221, -1, -1, 224, -1, 226, + 227, 228, 229, 230, 231, -1, -1, 234, -1, 236, + -1, -1, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 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, + 267, 268, -1, 270, 271, 272, 273, 274, -1, 276, + 277, -1, 279, -1, 281, 282, 283, 284, 285, 286, + -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, + 297, 298, 299, -1, 301, -1, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, + 317, -1, 319, 320, 321, -1, 323, 324, 325, 326, + 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, + -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 360, -1, 362, 363, -1, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, - 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, - 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, - 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, - 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, - 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 377, 378, 379, 380, 381, 382, -1, 384, 385, 386, + 387, 388, 389, 390, 391, 392, 393, -1, 395, 396, + 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, 412, 413, 414, 415, -1, + 417, 418, 419, 420, -1, 422, 423, 424, 425, 426, + -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, + 437, -1, 439, 440, 441, 442, 443, 444, 445, 446, + -1, -1, 449, 450, 451, 452, 453, 454, 455, 456, + -1, 458, 459, 460, 461, 462, 463, 464, -1, 466, + -1, 468, 469, 470, 471, 472, 473, 474, -1, -1, + 477, -1, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 3, -1, -1, -1, -1, -1, + 497, 498, 499, 500, 3, -1, 503, -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, + 517, -1, -1, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 43, 44, -1, 46, 47, 48, + -1, 50, 51, 52, 53, 54, -1, 56, 57, -1, + 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, + 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, + 79, -1, -1, -1, 83, 84, 85, 86, 87, 88, + -1, 90, 91, 92, -1, 94, 95, 96, 97, 98, + 99, -1, -1, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, + -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, + 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, + -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, - 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, - 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, - 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, - 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, - 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, - 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, + 159, -1, 161, -1, 163, 164, 165, 166, -1, 168, + -1, 170, -1, 172, -1, 174, 175, 176, -1, 178, + -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, + 189, 190, 191, 192, 193, -1, 195, 196, 197, 198, + -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, + -1, 210, 211, 212, 213, 214, 215, 216, 217, -1, + 219, -1, 221, -1, -1, 224, -1, 226, 227, 228, + 229, 230, 231, -1, -1, 234, -1, 236, -1, -1, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, - 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, - 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, - 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, + -1, 270, 271, 272, 273, 274, -1, 276, 277, -1, + 279, -1, 281, 282, 283, 284, 285, 286, -1, 288, + 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, + 299, -1, 301, -1, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, -1, + 319, 320, 321, -1, 323, 324, 325, 326, 327, 328, + -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, + 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, + 359, 360, -1, 362, 363, -1, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, - 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, - 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, - 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, - 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, - 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, - 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, - 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, + 379, 380, 381, 382, -1, 384, 385, 386, 387, 388, + 389, 390, 391, 392, -1, -1, 395, 396, 397, 398, + -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, + 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, + 419, 420, -1, 422, 423, 424, 425, 426, -1, 428, + 429, 430, -1, -1, 433, 434, 435, 436, 437, -1, + 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, + 449, 450, 451, 452, 453, 454, 455, 456, -1, 458, + 459, 460, 461, 462, 463, 464, -1, 466, -1, 468, + 469, 470, 471, 472, 473, 474, -1, -1, 477, -1, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, - 499, 500, 3, -1, -1, -1, -1, -1, -1, -1, + 499, 500, 3, -1, 503, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 517, -1, + -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, + 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, + 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, + 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, + 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, + -1, -1, 83, 84, 85, 86, 87, 88, -1, 90, + 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, + -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, + 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, + 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, + 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, -1, + 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, + -1, 172, -1, 174, 175, 176, -1, 178, -1, 180, + -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, + 191, 192, 193, -1, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, -1, 210, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, -1, -1, 224, -1, 226, 227, 228, 229, 230, + 231, -1, -1, 234, -1, 236, -1, -1, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, -1, 270, + 271, 272, 273, 274, -1, 276, 277, -1, 279, -1, + 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, + -1, 292, 293, 294, -1, -1, 297, 298, 299, -1, + 301, -1, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, -1, 319, 320, + 321, -1, 323, 324, 325, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, -1, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, 382, -1, 384, 385, 386, 387, 388, 389, 390, + 391, 392, -1, -1, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, 417, 418, 419, 420, + -1, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, 435, 436, 437, -1, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, 452, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, 463, 464, -1, 466, -1, 468, 469, 470, + 471, 472, 473, 474, -1, -1, 477, -1, 479, 480, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + -1, 3, 503, 5, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 517, -1, -1, -1, + 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, + 32, 33, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, + 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, + 62, 63, 64, -1, -1, 67, 68, 69, 70, 71, + 72, 73, -1, 75, 76, 77, 78, 79, -1, -1, + -1, 83, 84, 85, 86, 87, 88, -1, 90, 91, + 92, -1, 94, 95, 96, 97, 98, 99, -1, -1, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, + 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, + -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, + 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, -1, 161, + -1, 163, 164, 165, 166, -1, 168, -1, 170, -1, + -1, -1, 174, 175, 176, -1, 178, -1, 180, -1, + 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, + 192, 193, -1, 195, 196, 197, 198, -1, 200, 201, + 202, 203, 204, 205, 206, -1, 208, -1, 210, 211, + 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, + -1, -1, 224, -1, 226, 227, 228, 229, 230, 231, + -1, -1, 234, -1, 236, -1, -1, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, -1, 270, 271, + 272, 273, 274, -1, 276, 277, -1, 279, -1, 281, + 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, + 292, 293, 294, -1, -1, 297, 298, 299, -1, 301, + -1, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, + -1, 323, 324, 325, 326, 327, 328, -1, 330, 331, + 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, + 362, 363, -1, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, + -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, + 392, -1, -1, 395, 396, 397, 398, -1, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, -1, -1, 417, 418, -1, 420, -1, + 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, + -1, 433, 434, 435, 436, 437, -1, 439, 440, 441, + 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, + -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, + 462, 463, 464, -1, 466, -1, 468, 469, 470, 471, + 472, 473, 474, -1, -1, 477, -1, -1, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 498, 499, 500, 3, + -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 517, -1, -1, 22, 23, + 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, + 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, + 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, + 64, -1, -1, 67, 68, 69, 70, 71, 72, 73, + -1, 75, 76, 77, 78, 79, -1, -1, -1, 83, + 84, 85, 86, 87, 88, -1, 90, 91, 92, -1, + 94, 95, 96, 97, 98, 99, -1, -1, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, + 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, + 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, + 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, -1, 161, -1, 163, + 164, 165, 166, -1, 168, -1, 170, -1, -1, -1, + 174, 175, 176, -1, 178, -1, 180, -1, 182, 183, + 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, + -1, 195, 196, 197, 198, -1, 200, 201, 202, 203, + 204, 205, 206, -1, 208, -1, 210, 211, 212, 213, + 214, 215, 216, 217, -1, 219, -1, 221, -1, -1, + 224, -1, 226, 227, 228, 229, 230, 231, -1, -1, + 234, -1, 236, -1, -1, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, -1, 270, 271, 272, 273, + 274, -1, 276, 277, -1, 279, -1, 281, 282, 283, + 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, + 294, -1, -1, 297, 298, 299, -1, 301, -1, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, -1, -1, -1, -1, 319, 320, 321, -1, 323, + 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, + 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, + 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, + -1, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, + 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, + -1, 395, 396, 397, 398, -1, 400, 401, 402, 403, + 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, + 414, -1, -1, 417, 418, -1, 420, -1, 422, 423, + 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, + 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, + 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, + 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, + 464, -1, 466, -1, 468, 469, 470, 471, 472, 473, + 474, -1, -1, 477, -1, -1, 480, 481, 482, 483, + 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 499, 500, 3, -1, 5, -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, 498, 499, 500, - 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, 161, -1, - 163, 164, 165, 166, -1, 168, -1, 170, 171, -1, - 173, 174, 175, 176, 177, 178, -1, 180, -1, 182, - 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, -1, 200, 201, 202, - 203, 204, 205, 206, -1, 208, 209, 210, 211, 212, - 213, 214, 215, 216, 217, -1, 219, -1, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, 231, -1, - -1, 234, 235, 236, 237, -1, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, -1, 276, 277, 278, 279, -1, 281, 282, - 283, 284, 285, 286, -1, 288, 289, 290, -1, 292, - 293, 294, -1, -1, 297, 298, 299, 300, 301, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, -1, -1, -1, -1, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, - 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, - 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, - -1, 394, 395, 396, 397, 398, -1, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, -1, -1, 417, 418, -1, 420, 421, 422, - 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, - 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, - 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, - 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, - 463, 464, -1, 466, 467, 468, 469, 470, 471, 472, - 473, 474, -1, -1, 477, -1, -1, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 498, 499, 500, 3, -1, + -1, -1, -1, 517, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, + 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, + 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, + -1, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, -1, -1, 83, 84, 85, + 86, 87, 88, -1, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, -1, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, + -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, + 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, -1, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, -1, -1, -1, 174, 175, + 176, -1, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, -1, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, -1, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, -1, -1, 224, -1, + 226, 227, 228, 229, 230, 231, -1, -1, 234, -1, + 236, -1, -1, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, -1, 270, 271, 272, 273, 274, -1, + 276, 277, -1, 279, -1, 281, 282, 283, 284, 285, + 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, + -1, 297, 298, 299, -1, 301, -1, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, -1, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, -1, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, -1, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, -1, 420, -1, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 436, 437, -1, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, -1, + 466, -1, 468, 469, 470, 471, 472, 473, 474, -1, + -1, 477, -1, -1, 480, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 3, -1, 5, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 517, -1, -1, 22, 23, 24, 25, 26, 27, + 28, 29, -1, 31, 32, 33, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 43, 44, -1, 46, 47, + 48, -1, 50, 51, 52, 53, 54, -1, 56, 57, + -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, + 68, 69, 70, 71, 72, 73, -1, 75, 76, 77, + 78, 79, -1, -1, -1, 83, 84, 85, 86, 87, + 88, -1, 90, 91, 92, -1, 94, 95, 96, 97, + 98, 99, -1, -1, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, + 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, + 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, + 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, -1, 161, -1, 163, 164, 165, 166, -1, + 168, -1, 170, -1, -1, -1, 174, 175, 176, -1, + 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, + 188, 189, 190, 191, 192, 193, -1, 195, 196, 197, + 198, -1, 200, 201, 202, 203, 204, 205, 206, -1, + 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, + -1, 219, -1, 221, -1, -1, 224, -1, 226, 227, + 228, 229, 230, 231, -1, -1, 234, -1, 236, -1, + -1, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, -1, 270, 271, 272, 273, 274, -1, 276, 277, + -1, 279, -1, 281, 282, 283, 284, 285, 286, -1, + 288, 289, -1, -1, 292, 293, 294, -1, -1, 297, + 298, 299, -1, 301, -1, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, + -1, 319, 320, 321, -1, 323, 324, 325, 326, 327, + 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, + 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, -1, 362, 363, -1, 365, 366, 367, + 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, + 378, 379, 380, 381, -1, -1, 384, 385, 386, 387, + 388, 389, 390, 391, 392, -1, -1, 395, 396, 397, + 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, + 408, 409, 410, 411, 412, 413, 414, -1, -1, 417, + 418, -1, 420, -1, 422, 423, 424, 425, 426, -1, + 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, + -1, 439, 440, 441, 442, 443, 444, 445, 446, -1, + -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, + 458, 459, 460, 461, 462, 463, 464, -1, 466, -1, + 468, 469, 470, 471, 472, 473, 474, -1, -1, 477, + -1, -1, 480, 481, 482, 483, 484, 485, 486, 487, + 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, + 498, 499, 500, 3, -1, 5, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 517, + -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, + -1, 31, 32, 33, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, + 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, + 60, 61, 62, 63, 64, -1, -1, 67, 68, 69, + 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, + -1, -1, -1, 83, 84, 85, 86, 87, 88, -1, + 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, + -1, -1, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, + 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, + 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, + 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + -1, 161, -1, 163, 164, 165, 166, -1, 168, -1, + 170, -1, -1, -1, 174, 175, 176, -1, 178, -1, + 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, + 190, 191, 192, 193, -1, 195, 196, 197, 198, -1, + 200, 201, 202, 203, 204, 205, 206, -1, 208, -1, + 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, + -1, 221, -1, -1, 224, -1, 226, 227, 228, 229, + 230, 231, -1, -1, 234, -1, 236, -1, -1, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, -1, + 270, 271, 272, 273, 274, -1, 276, 277, -1, 279, + -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, + -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, + -1, 301, -1, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, + 320, 321, -1, 323, 324, 325, 326, 327, 328, -1, + 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, + 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, -1, 362, 363, -1, 365, 366, 367, 368, 369, + 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, + 380, 381, -1, -1, 384, 385, 386, 387, 388, 389, + 390, 391, 392, -1, -1, 395, 396, 397, 398, -1, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, -1, -1, 417, 418, -1, + 420, -1, 422, 423, 424, 425, 426, -1, 428, 429, + 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, + 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, + 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, + 460, 461, 462, 463, 464, -1, 466, -1, 468, 469, + 470, 471, 472, 473, 474, -1, -1, 477, -1, -1, + 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, + 500, 3, -1, 5, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 517, -1, -1, + 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, + 32, 33, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, + 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, + 62, 63, 64, -1, -1, 67, 68, 69, 70, 71, + 72, 73, -1, 75, 76, 77, 78, 79, -1, -1, + -1, 83, 84, 85, 86, 87, 88, -1, 90, 91, + 92, -1, 94, 95, 96, 97, 98, 99, -1, -1, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, + 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, + -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, + 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, -1, 161, + -1, 163, 164, 165, 166, -1, 168, -1, 170, -1, + -1, -1, 174, 175, 176, -1, 178, -1, 180, -1, + 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, + 192, 193, -1, 195, 196, 197, 198, -1, 200, 201, + 202, 203, 204, 205, 206, -1, 208, -1, 210, 211, + 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, + -1, -1, 224, -1, 226, 227, 228, 229, 230, 231, + -1, -1, 234, -1, 236, -1, -1, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, -1, 270, 271, + 272, 273, 274, -1, 276, 277, -1, 279, -1, 281, + 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, + 292, 293, 294, -1, -1, 297, 298, 299, -1, 301, + -1, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, + -1, 323, 324, 325, 326, 327, 328, -1, 330, 331, + 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, + 362, 363, -1, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, + -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, + 392, -1, -1, 395, 396, 397, 398, -1, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, -1, -1, 417, 418, -1, 420, -1, + 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, + -1, 433, 434, 435, 436, 437, -1, 439, 440, 441, + 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, + -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, + 462, 463, 464, -1, 466, -1, 468, 469, 470, 471, + 472, 473, 474, -1, -1, 477, -1, -1, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 498, 499, 500, 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, 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, 159, -1, 161, -1, 163, 164, - 165, 166, -1, 168, -1, 170, 171, -1, 173, 174, - 175, 176, 177, 178, -1, 180, -1, 182, 183, 184, - 185, -1, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, - 205, 206, -1, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, -1, 219, -1, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, -1, -1, 234, - 235, 236, 237, -1, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - -1, 276, 277, 278, 279, -1, 281, 282, 283, 284, - 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, - -1, -1, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - -1, -1, -1, -1, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, - 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, - 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, -1, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, 379, 380, 381, -1, 383, 384, - 385, 386, 387, 388, 389, 390, 391, 392, -1, 394, - 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, - -1, -1, 417, 418, -1, 420, 421, 422, 423, 424, - 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, - 435, 436, 437, -1, 439, 440, 441, 442, 443, 444, - 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, - 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, - -1, 466, 467, 468, 469, 470, 471, 472, 473, 474, - -1, -1, 477, -1, -1, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 499, 500, 3, -1, -1, -1, + -1, -1, -1, -1, -1, 517, -1, -1, 22, 23, + 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, + 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, + 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, + 64, -1, -1, 67, 68, 69, 70, 71, 72, 73, + -1, 75, 76, 77, 78, 79, -1, -1, -1, 83, + 84, 85, 86, 87, 88, -1, 90, 91, 92, -1, + 94, 95, 96, 97, 98, 99, -1, -1, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, + 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, + 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, + 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, -1, 161, -1, 163, + 164, 165, 166, -1, 168, -1, 170, -1, -1, -1, + 174, 175, 176, -1, 178, -1, 180, -1, 182, 183, + 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, + -1, 195, 196, 197, 198, -1, 200, 201, 202, 203, + 204, 205, 206, -1, 208, -1, 210, 211, 212, 213, + 214, 215, 216, 217, -1, 219, -1, 221, -1, -1, + 224, -1, 226, 227, 228, 229, 230, 231, -1, -1, + 234, -1, 236, -1, -1, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, -1, 270, 271, 272, 273, + 274, -1, 276, 277, -1, 279, -1, 281, 282, 283, + 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, + 294, -1, -1, 297, 298, 299, -1, 301, -1, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, -1, -1, -1, -1, 319, 320, 321, -1, 323, + 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, + 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, + 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, + -1, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, + 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, + -1, 395, 396, 397, 398, -1, 400, 401, 402, 403, + 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, + 414, -1, -1, 417, 418, -1, 420, -1, 422, 423, + 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, + 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, + 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, + 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, + 464, -1, 466, -1, 468, 469, 470, 471, 472, 473, + 474, -1, -1, 477, -1, -1, 480, 481, 482, 483, + 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 499, 500, 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, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, -1, 66, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, -1, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, - 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - 237, -1, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, -1, 276, - 277, 278, 279, -1, 281, 282, 283, 284, 285, 286, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, -1, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, -1, 466, - 467, 468, 469, 470, 471, 472, 473, 474, -1, -1, - 477, -1, -1, 480, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 3, -1, -1, -1, -1, -1, + -1, -1, -1, 517, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, + 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, + 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, + -1, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, -1, -1, 83, 84, 85, + 86, 87, 88, -1, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, -1, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, + -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, + 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, -1, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, -1, -1, -1, 174, 175, + 176, -1, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, -1, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, -1, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, -1, -1, 224, -1, + 226, 227, 228, 229, 230, 231, -1, -1, 234, -1, + 236, -1, -1, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, -1, 270, 271, 272, 273, 274, -1, + 276, 277, -1, 279, -1, 281, 282, 283, 284, 285, + 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, + -1, 297, 298, 299, -1, 301, -1, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, -1, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, -1, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, -1, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, -1, 420, -1, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 436, 437, -1, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, -1, + 466, -1, 468, 469, 470, 471, 472, 473, 474, -1, + -1, 477, -1, -1, 480, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 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, 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, -1, 161, -1, 163, 164, 165, 166, -1, 168, - -1, 170, 171, -1, 173, 174, 175, 176, 177, 178, - -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, + -1, 517, -1, -1, 22, 23, 24, 25, 26, 27, + 28, 29, -1, 31, 32, 33, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 43, 44, -1, 46, 47, + 48, -1, 50, 51, 52, 53, 54, -1, 56, 57, + -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, + 68, 69, 70, 71, 72, 73, -1, 75, 76, 77, + 78, 79, -1, -1, -1, 83, 84, 85, 86, 87, + 88, -1, 90, 91, 92, -1, 94, 95, 96, 97, + 98, 99, -1, -1, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, + 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, + 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, + 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, -1, 161, -1, 163, 164, 165, 166, -1, + 168, -1, 170, -1, -1, -1, 174, 175, 176, -1, + 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, + 188, 189, 190, 191, 192, 193, -1, 195, 196, 197, + 198, -1, 200, 201, 202, 203, 204, 205, 206, -1, + 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, + -1, 219, -1, 221, -1, -1, 224, -1, 226, 227, + 228, 229, 230, 231, -1, -1, 234, -1, 236, -1, + -1, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, -1, 270, 271, 272, 273, 274, -1, 276, 277, + -1, 279, -1, 281, 282, 283, 284, 285, 286, -1, + 288, 289, -1, -1, 292, 293, 294, -1, -1, 297, + 298, 299, -1, 301, -1, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, + -1, 319, 320, 321, -1, 323, 324, 325, 326, 327, + 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, + 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, -1, 362, 363, -1, 365, 366, 367, + 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, + 378, 379, 380, 381, -1, -1, 384, 385, 386, 387, + 388, 389, 390, 391, 392, -1, -1, 395, 396, 397, + 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, + 408, 409, 410, 411, 412, 413, 414, -1, -1, 417, + 418, -1, 420, -1, 422, 423, 424, 425, 426, -1, + 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, + -1, 439, 440, 441, 442, 443, 444, 445, 446, -1, + -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, + 458, 459, 460, 461, 462, 463, 464, -1, 466, -1, + 468, 469, 470, 471, 472, 473, 474, -1, -1, 477, + -1, -1, 480, 481, 482, 483, 484, 485, 486, 487, + 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, + 498, 499, 500, -1, 3, 4, 5, -1, -1, 8, + 9, -1, -1, -1, -1, -1, 15, 16, -1, 517, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, -1, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + -1, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, + 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, + 149, 150, 151, -1, 153, 154, 155, 156, 157, 158, + -1, 160, 161, 162, 163, 164, 165, 166, 167, 168, + 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, + 179, 180, 181, -1, -1, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, - -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, - 209, 210, 211, 212, 213, 214, 215, 216, 217, -1, - 219, -1, 221, 222, 223, 224, 225, 226, 227, 228, - 229, 230, 231, -1, -1, 234, 235, 236, 237, -1, + 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, + 209, -1, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, 274, -1, 276, 277, 278, - 279, -1, 281, 282, 283, 284, 285, 286, -1, 288, - 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, - 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, - 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, - 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, + 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, + 279, 280, -1, 282, 283, 284, 285, 286, 287, 288, + 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, + -1, 300, 301, 302, -1, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, -1, 322, 323, 324, -1, 326, 327, 328, + 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, + 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, + 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, - 379, 380, 381, -1, -1, 384, 385, 386, 387, 388, - 389, 390, 391, 392, -1, 394, 395, 396, 397, 398, - -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, - -1, 420, 421, 422, 423, 424, 425, 426, -1, 428, - 429, 430, -1, -1, 433, 434, 435, 436, 437, -1, - 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, - 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, - 459, 460, 461, 462, 463, 464, -1, 466, 467, 468, - 469, 470, 471, 472, 473, 474, -1, -1, 477, -1, - -1, 480, 481, 482, 483, 484, 485, 486, 487, 488, - 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, - 499, 500, 3, -1, -1, -1, -1, -1, -1, -1, + 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, + 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, + 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, + 409, 410, 411, 412, 413, -1, 415, 416, 417, 418, + 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, + 429, 430, 431, 432, 433, 434, -1, 436, -1, 438, + 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, + 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, + 459, 460, 461, 462, -1, 464, 465, 466, 467, 468, + 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, + 479, 480, 481, 482, 483, 484, 485, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 497, 498, + 499, 500, -1, 3, -1, 504, 505, 506, 8, 508, + 509, 510, 511, 512, 513, 15, 16, -1, -1, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + -1, 31, 32, 33, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, + 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, + 60, 61, 62, 63, 64, -1, -1, 67, 68, 69, + 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, + -1, -1, -1, 83, 84, 85, 86, 87, 88, -1, + 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, + -1, -1, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, + 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, + 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, + 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + -1, 161, -1, 163, 164, 165, 166, -1, 168, -1, + 170, -1, -1, -1, 174, 175, 176, -1, 178, -1, + 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, + 190, 191, 192, 193, -1, 195, 196, 197, 198, -1, + 200, 201, 202, 203, 204, 205, 206, -1, 208, -1, + 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, + -1, 221, -1, -1, 224, -1, 226, 227, 228, 229, + 230, 231, -1, -1, 234, -1, 236, -1, -1, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, -1, + 270, 271, 272, 273, 274, -1, 276, 277, -1, 279, + -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, + -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, + -1, 301, -1, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, + 320, 321, -1, 323, 324, 325, 326, 327, 328, -1, + 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, + 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, -1, 362, 363, -1, 365, 366, 367, 368, 369, + 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, + 380, 381, -1, -1, 384, 385, 386, 387, 388, 389, + 390, 391, 392, -1, -1, 395, 396, 397, 398, -1, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, -1, -1, 417, 418, -1, + 420, -1, 422, 423, 424, 425, 426, -1, 428, 429, + 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, + 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, + 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, + 460, 461, 462, 463, 464, -1, 466, -1, 468, 469, + 470, 471, 472, 473, 474, -1, -1, 477, -1, -1, + 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, + 500, -1, -1, -1, 504, 505, 506, -1, 508, 509, + 510, 511, 512, 513, 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, 22, 23, 24, 25, 26, 27, 28, 29, -1, - 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, - 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, - 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, - 71, 72, 73, 74, 75, 76, 77, 78, 79, -1, - -1, 82, 83, 84, 85, 86, 87, 88, -1, 90, - 91, 92, 93, 94, 95, 96, 97, 98, 99, -1, - -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, - 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, - 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, - 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, -1, - 161, -1, 163, 164, 165, 166, -1, 168, 169, 170, - -1, -1, -1, 174, 175, 176, -1, 178, -1, 180, - -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, - 191, 192, 193, -1, 195, 196, 197, 198, -1, 200, - 201, 202, 203, 204, 205, 206, -1, 208, -1, 210, - 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, - 221, -1, -1, 224, -1, 226, 227, 228, 229, 230, - 231, -1, -1, 234, -1, 236, -1, -1, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, -1, 270, - 271, 272, 273, 274, -1, 276, 277, -1, 279, -1, - 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, - -1, 292, 293, 294, -1, -1, 297, 298, 299, -1, - 301, -1, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, - 321, -1, 323, 324, 325, 326, 327, 328, 329, 330, - 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - -1, 362, 363, -1, 365, 366, 367, 368, 369, 370, - 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, - 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, - 391, 392, -1, -1, 395, 396, 397, 398, -1, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, - -1, 422, 423, 424, 425, 426, -1, 428, 429, 430, - -1, -1, 433, 434, 435, 436, 437, -1, 439, 440, - 441, 442, 443, 444, 445, 446, -1, 448, 449, 450, - 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, - 461, 462, 463, 464, -1, 466, -1, 468, 469, 470, - 471, 472, 473, 474, -1, -1, 477, -1, -1, 480, - 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, - 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, - 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, 159, -1, 161, -1, - 163, 164, 165, 166, -1, 168, 169, 170, -1, -1, - -1, 174, 175, 176, -1, 178, -1, 180, -1, 182, - 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, - 193, -1, 195, 196, 197, 198, -1, 200, 201, 202, - 203, 204, 205, 206, -1, 208, -1, 210, 211, 212, - 213, 214, 215, 216, 217, -1, 219, -1, 221, -1, - -1, 224, -1, 226, 227, 228, 229, 230, 231, -1, - -1, 234, -1, 236, 237, -1, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, -1, 270, 271, 272, - 273, 274, -1, 276, 277, -1, 279, -1, 281, 282, - 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, - 293, 294, -1, -1, 297, 298, 299, -1, 301, -1, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, -1, -1, -1, -1, 319, 320, 321, -1, - 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, - 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, - 363, -1, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, - -1, 384, 385, 386, 387, 388, 389, 390, 391, 392, - -1, -1, 395, 396, 397, 398, -1, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, -1, -1, 417, 418, -1, 420, -1, 422, - 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, - 433, 434, 435, 436, 437, -1, 439, 440, 441, 442, - 443, 444, 445, 446, -1, 448, 449, 450, 451, -1, - 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, - 463, 464, -1, 466, -1, 468, 469, 470, 471, 472, - 473, 474, -1, -1, 477, -1, -1, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 498, 499, 500, 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, + -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, 24, -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, 81, -1, 15, 16, 17, 18, + 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, + 97, -1, -1, -1, 80, -1, -1, 36, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 46, 8, -1, + -1, 11, -1, 177, 53, 15, 16, 17, 18, 19, + 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, + 194, -1, -1, -1, -1, 199, 36, -1, -1, 146, + -1, 80, -1, -1, -1, -1, 46, -1, -1, 156, + -1, -1, 177, 53, -1, -1, -1, -1, 222, 223, + -1, -1, 169, -1, -1, -1, -1, 174, -1, 194, + -1, -1, -1, 237, 199, -1, -1, -1, -1, -1, + 80, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 177, -1, -1, -1, -1, 203, 222, 223, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 194, -1, + -1, 275, 237, 199, 278, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 292, -1, + -1, 295, -1, -1, -1, -1, 222, 223, 177, 246, + -1, -1, -1, 250, -1, -1, -1, -1, -1, -1, + 275, 237, -1, 278, -1, 194, -1, -1, -1, -1, + 199, -1, -1, -1, -1, -1, -1, 292, -1, -1, + 295, -1, -1, -1, -1, -1, -1, 177, -1, -1, + -1, -1, -1, 222, 223, -1, -1, -1, -1, 275, + -1, -1, 278, -1, 194, -1, -1, -1, 237, 199, + -1, -1, -1, -1, -1, -1, 292, 314, -1, 295, + -1, -1, -1, 320, -1, -1, -1, -1, -1, -1, + -1, -1, 222, 223, -1, -1, -1, -1, 335, -1, + 394, -1, -1, -1, -1, -1, 275, 237, -1, 278, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 292, -1, -1, 295, -1, -1, -1, + -1, -1, -1, 370, -1, -1, 373, -1, -1, 394, + -1, -1, -1, -1, -1, 275, -1, 384, 278, -1, + 387, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 292, -1, -1, 295, -1, -1, 405, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 394, -1, + -1, -1, 419, -1, -1, -1, -1, -1, 425, 426, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 436, + -1, -1, -1, -1, -1, 442, -1, 501, -1, -1, + 504, 505, 506, -1, 508, 509, 510, 511, 512, 513, + -1, -1, -1, -1, 518, 394, -1, -1, -1, -1, + -1, 8, 469, -1, 11, -1, -1, -1, 15, 16, + 17, 18, 19, 20, 21, -1, 501, -1, -1, 504, + 505, 506, -1, 508, 509, 510, 511, 512, 513, 36, + -1, -1, -1, 518, 394, -1, -1, -1, -1, 46, + -1, -1, -1, -1, -1, -1, 53, -1, -1, -1, + -1, -1, -1, -1, -1, 501, -1, -1, 504, 505, + 506, -1, 508, 509, 510, 511, 512, 513, -1, -1, + -1, -1, 518, 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, 501, -1, -1, 504, 505, 506, -1, 508, + 509, 510, 511, 512, 513, 36, -1, -1, -1, 518, + -1, -1, -1, -1, -1, 46, 8, -1, -1, 11, + -1, -1, 53, 15, 16, 17, 18, 19, 20, 21, + -1, 501, -1, -1, 504, 505, 506, -1, 508, 509, + 510, 511, 512, 513, 36, -1, -1, -1, 518, 80, + -1, -1, -1, -1, 46, 8, -1, -1, 11, -1, + 177, 53, 15, 16, 17, 18, 19, 20, 21, -1, + -1, -1, -1, -1, -1, -1, -1, 194, -1, -1, + -1, -1, 199, 36, -1, -1, -1, -1, 80, -1, + -1, -1, -1, 46, -1, -1, -1, -1, -1, -1, + 53, -1, -1, -1, -1, 222, 223, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 237, -1, -1, -1, -1, -1, -1, 80, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 8, -1, -1, 11, -1, 177, -1, 15, 16, + 17, 18, 19, 20, 21, -1, -1, -1, 275, -1, + -1, 278, -1, 194, -1, -1, -1, -1, 199, 36, + -1, -1, -1, -1, -1, 292, -1, -1, 295, 46, + -1, -1, -1, -1, -1, 177, 53, -1, -1, -1, + -1, 222, 223, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 194, -1, -1, -1, 237, 199, -1, -1, + -1, -1, -1, 80, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 177, -1, -1, -1, -1, -1, + 222, 223, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 194, -1, -1, 275, 237, 199, 278, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 292, -1, -1, 295, -1, -1, -1, -1, 222, + 223, -1, -1, -1, -1, -1, -1, 394, -1, -1, + -1, -1, -1, 275, 237, -1, 278, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 292, -1, -1, 295, -1, -1, -1, -1, -1, -1, + 177, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 275, -1, -1, 278, -1, 194, -1, -1, + -1, -1, 199, -1, -1, -1, -1, -1, -1, 292, + -1, -1, 295, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 222, 223, -1, -1, -1, + -1, -1, -1, 394, -1, -1, -1, -1, -1, -1, + 237, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 501, -1, -1, 504, 505, 506, + -1, 508, 509, 510, 511, 512, 513, -1, -1, -1, + -1, 518, 394, -1, -1, -1, -1, -1, 275, -1, + -1, 278, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 292, -1, -1, 295, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 394, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 501, -1, -1, 504, 505, 506, -1, 508, 509, 510, + 511, 512, 513, -1, -1, -1, -1, 518, -1, -1, + -1, -1, -1, -1, 8, -1, -1, 11, -1, -1, + -1, 15, 16, 17, 18, 19, 20, 21, -1, 501, + -1, -1, 504, 505, 506, -1, 508, 509, 510, 511, + 512, 513, 36, -1, -1, -1, 518, 394, 24, -1, + -1, -1, 46, 8, -1, -1, 11, -1, -1, 53, + 15, 16, 17, 18, 19, 20, 21, -1, 501, -1, + -1, 504, 505, 506, -1, 508, 509, 510, 511, 512, + 513, 36, -1, -1, -1, 518, 80, -1, -1, -1, + -1, 46, -1, -1, -1, -1, -1, -1, 53, -1, + 8, -1, -1, 11, -1, 81, -1, 15, 16, 17, + 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, + -1, 97, -1, -1, -1, 80, -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, 501, -1, -1, 504, 505, 506, + -1, 508, 509, 510, 511, 512, 513, 36, -1, -1, + 146, 518, 80, -1, -1, -1, -1, 46, 8, -1, + 156, 11, -1, 177, 53, 15, 16, 17, 18, 19, + 20, 21, -1, 169, -1, -1, -1, -1, 174, -1, + 194, -1, -1, -1, -1, 199, 36, -1, -1, -1, + -1, 80, -1, -1, -1, -1, 46, -1, -1, -1, + -1, -1, 177, 53, -1, -1, -1, 203, 222, 223, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 194, + -1, -1, -1, 237, 199, -1, -1, -1, -1, -1, + 80, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 222, 223, 177, + 246, -1, -1, -1, 250, -1, -1, -1, -1, -1, + -1, 275, 237, -1, 278, -1, 194, -1, -1, -1, + -1, 199, -1, -1, -1, -1, -1, -1, 292, -1, + -1, 295, -1, -1, -1, -1, -1, -1, 177, -1, + -1, -1, -1, -1, 222, 223, -1, -1, -1, -1, + 275, -1, -1, 278, -1, 194, -1, -1, -1, 237, + 199, -1, -1, -1, -1, -1, -1, 292, -1, -1, + 295, -1, -1, -1, 320, -1, -1, 177, -1, -1, + -1, -1, -1, 222, 223, -1, -1, -1, -1, 335, + -1, -1, -1, -1, 194, -1, -1, 275, 237, 199, + 278, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 292, -1, -1, 295, -1, -1, + -1, -1, 222, 223, 370, -1, -1, 373, -1, -1, + 394, -1, -1, -1, -1, -1, 275, 237, 384, 278, + -1, 387, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 292, -1, -1, 295, -1, -1, 405, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 394, + -1, -1, -1, 419, -1, 275, -1, -1, 278, -1, + 426, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 436, -1, 292, -1, -1, 295, 442, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 394, -1, -1, -1, + -1, -1, -1, 469, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 501, -1, -1, + 504, 505, 506, -1, 508, 509, 510, 511, 512, 513, + -1, -1, -1, -1, 518, 394, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 501, -1, -1, 504, + 505, 506, -1, 508, 509, 510, 511, 512, 513, -1, + -1, 516, -1, -1, 394, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 501, -1, -1, 504, 505, 506, -1, + 508, 509, 510, 511, 512, 513, -1, -1, 516, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 501, -1, -1, 504, 505, 506, -1, 508, + 509, 510, 511, 512, 513, -1, -1, 516, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 3, -1, + -1, 501, -1, -1, 504, 505, 506, -1, 508, 509, + 510, 511, 512, 513, -1, -1, 516, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, - 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, - 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, - 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, -1, 161, -1, 163, 164, - 165, 166, -1, 168, -1, 170, -1, -1, -1, 174, - 175, 176, -1, 178, -1, 180, -1, 182, 183, 184, - 185, -1, 187, 188, 189, 190, 191, 192, 193, -1, - 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, - 205, 206, -1, 208, -1, 210, 211, 212, 213, 214, - 215, 216, 217, -1, 219, -1, 221, -1, -1, 224, - -1, 226, 227, 228, 229, 230, 231, -1, -1, 234, - -1, 236, -1, -1, 239, 240, 241, 242, 243, 244, + 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, + 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, + 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, + 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, + 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, + 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, -1, 270, 271, 272, 273, 274, - -1, 276, 277, -1, 279, -1, 281, 282, 283, 284, - 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, - -1, -1, 297, 298, 299, -1, 301, -1, 303, 304, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - -1, -1, -1, -1, 319, 320, 321, -1, 323, 324, - 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, - 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, - 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, -1, 362, 363, -1, + 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, + 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, + 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, - 385, 386, 387, 388, 389, 390, 391, 392, -1, -1, - 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, + 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, + 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, + 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, - -1, -1, 417, 418, -1, 420, -1, 422, 423, 424, - 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, - 435, 436, 437, -1, 439, 440, 441, 442, 443, 444, - 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, - 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, - -1, 466, -1, 468, 469, 470, 471, 472, 473, 474, - -1, -1, 477, -1, -1, 480, 481, 482, 483, 484, + 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, 3, -1, 5, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 495, 496, 497, 498, 499, 500, 3, -1, -1, -1, + -1, -1, -1, -1, -1, 510, -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, -1, -1, -1, + 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, @@ -15656,8 +15925,8 @@ static const yytype_int16 yycheck[] = -1, 468, 469, 470, 471, 472, 473, 474, -1, -1, 477, -1, -1, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 3, -1, 5, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 497, 498, 499, 500, 3, -1, -1, -1, -1, -1, + -1, -1, -1, 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, @@ -15685,7 +15954,7 @@ static const yytype_int16 yycheck[] = 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, -1, 270, 271, 272, 273, 274, -1, 276, 277, -1, 279, -1, 281, 282, 283, 284, 285, 286, -1, 288, - 289, -1, 291, 292, 293, 294, -1, -1, 297, 298, + 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, -1, 301, -1, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, -1, 323, 324, 325, 326, 327, 328, @@ -15706,1202 +15975,1610 @@ static const yytype_int16 yycheck[] = 469, 470, 471, 472, 473, 474, -1, -1, 477, -1, -1, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, - 499, 500, 3, -1, 5, -1, -1, -1, -1, -1, + 499, 500, 3, 4, 5, -1, -1, -1, 9, -1, + -1, 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, 37, -1, -1, -1, + -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, + 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, + 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, + 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, + 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, + 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, + 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, + 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, + -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, -1, -1, 234, 235, 236, 237, -1, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, + 271, 272, 273, 274, -1, 276, 277, 278, 279, -1, + 281, 282, 283, 284, 285, 286, -1, 288, 289, 290, + -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, -1, 383, 384, 385, 386, 387, 388, 389, 390, + 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, + 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, 463, 464, -1, 466, 467, 468, 469, 470, + 471, 472, 473, 474, -1, -1, 477, -1, -1, 480, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + -1, -1, 8, -1, -1, 11, -1, 508, 509, 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, 40, 80, -1, -1, -1, -1, 46, -1, + -1, -1, -1, -1, -1, 53, -1, -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, 80, -1, -1, -1, -1, 36, -1, -1, + -1, 167, -1, -1, -1, -1, 172, 46, -1, -1, + -1, 177, -1, -1, 53, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 194, -1, + -1, -1, -1, 199, -1, -1, -1, -1, -1, 166, + -1, 80, -1, -1, -1, -1, -1, -1, -1, -1, + 177, -1, -1, -1, -1, -1, 222, 223, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 194, -1, -1, + -1, 237, 199, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 177, + -1, -1, -1, -1, -1, 222, 223, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 194, -1, -1, 275, + 237, 199, 278, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 292, -1, -1, 295, + -1, -1, -1, -1, 222, 223, -1, -1, 177, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 275, 237, + -1, 278, -1, -1, -1, 194, -1, -1, -1, -1, + 199, -1, -1, -1, -1, 292, -1, -1, 295, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 222, 223, -1, -1, 275, -1, -1, + 278, -1, -1, -1, -1, -1, -1, 324, 237, -1, + -1, -1, -1, -1, 292, -1, -1, 295, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 394, -1, + -1, -1, -1, -1, -1, -1, 275, -1, -1, 278, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 292, -1, 3, 295, 5, -1, -1, + -1, -1, 8, -1, -1, 11, -1, 394, -1, 15, + 16, 17, 18, 19, 20, 21, -1, -1, -1, 318, + -1, -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, 394, 53, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 68, 69, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 80, 501, -1, -1, 504, 505, + 506, -1, 508, 509, 510, 511, 512, 513, -1, -1, + -1, -1, -1, -1, -1, 394, -1, -1, -1, -1, + -1, 109, 110, -1, -1, 113, 114, -1, -1, -1, + -1, -1, -1, -1, 501, -1, -1, 504, 505, 506, + -1, 508, 509, 510, 511, 512, 513, -1, -1, -1, + -1, 8, -1, -1, 11, -1, -1, -1, 15, 16, + 17, 18, 19, 20, 21, -1, -1, -1, -1, -1, + -1, -1, -1, 501, -1, -1, 504, 505, 506, 36, + 508, 509, 510, 511, 512, 513, -1, -1, -1, 46, + -1, 177, -1, -1, -1, -1, 53, -1, -1, -1, + -1, 189, 190, -1, -1, -1, -1, -1, 194, -1, + -1, -1, -1, 199, -1, -1, -1, -1, -1, -1, + -1, -1, 501, 80, -1, 504, 505, 506, -1, 508, + 509, 510, 511, 512, 513, -1, 222, 223, -1, -1, + -1, -1, -1, -1, -1, -1, 8, -1, -1, 11, + -1, 237, -1, 15, 16, 17, 18, 19, 20, 21, + -1, -1, -1, -1, -1, 253, 254, 255, 256, 257, + 258, 259, 260, -1, 36, 263, 264, -1, 40, -1, + -1, -1, -1, -1, 46, -1, -1, -1, -1, 275, + -1, 53, 278, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 292, -1, -1, 295, + -1, -1, -1, -1, -1, 172, -1, -1, 80, -1, + 177, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 194, -1, -1, + -1, -1, 199, -1, -1, -1, -1, -1, -1, 337, + 338, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 222, 223, -1, -1, -1, + -1, -1, -1, -1, -1, 8, -1, -1, 11, -1, + 237, -1, 15, 16, 17, 18, 19, 20, 21, -1, + 378, 379, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 36, -1, -1, -1, -1, 394, -1, + -1, -1, -1, 46, -1, 177, -1, -1, 275, -1, + 53, 278, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 194, -1, -1, 292, -1, 199, 295, -1, + -1, -1, -1, -1, -1, -1, -1, 80, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 222, 223, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 237, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 473, 474, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 497, + 498, -1, -1, 275, -1, 501, 278, -1, 504, 505, + 506, -1, 508, 509, 510, 511, 512, 513, -1, -1, + 292, -1, -1, 295, 167, -1, -1, 394, -1, 8, + -1, -1, 11, -1, 177, -1, 15, 16, 17, 18, + 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, + -1, 194, -1, -1, -1, -1, 199, 36, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 46, -1, -1, + -1, -1, -1, -1, 53, -1, -1, -1, -1, 222, + 223, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 237, -1, -1, -1, -1, -1, + -1, 80, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 394, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 275, -1, 501, 278, -1, 504, 505, 506, + -1, 508, 509, 510, 511, 512, 513, -1, -1, 292, + -1, -1, 295, -1, -1, -1, -1, -1, 8, -1, + -1, 11, -1, -1, -1, 15, 16, 17, 18, 19, + 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 36, -1, -1, -1, + 40, -1, -1, -1, -1, -1, 46, -1, 177, -1, + -1, -1, -1, 53, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 194, -1, -1, -1, -1, + 199, -1, -1, -1, -1, -1, -1, -1, -1, 501, + 80, -1, 504, 505, 506, -1, 508, 509, 510, 511, + 512, 513, -1, 222, 223, -1, -1, -1, -1, -1, + -1, 394, -1, 8, -1, -1, 11, -1, 237, -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, 275, -1, 53, 278, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 68, 69, 292, -1, -1, 295, -1, -1, -1, + -1, -1, -1, -1, -1, 80, -1, 177, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 194, -1, -1, -1, -1, 199, + -1, -1, 109, 110, -1, -1, 113, 114, 501, -1, + -1, 504, 505, 506, -1, 508, 509, 510, 511, 512, + 513, -1, 222, 223, -1, -1, -1, -1, -1, -1, + -1, -1, 8, -1, -1, 11, -1, 237, -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, 394, -1, -1, -1, -1, + 46, -1, 177, -1, -1, 275, -1, 53, 278, -1, + -1, -1, 189, 190, -1, -1, -1, -1, -1, 194, + -1, -1, 292, -1, 199, 295, -1, -1, 427, -1, + -1, -1, -1, -1, 80, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 222, 223, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 237, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 253, 254, 255, 256, + 257, 258, 259, 260, -1, -1, 263, 264, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 275, -1, 501, 278, -1, 504, 505, 506, -1, 508, + 509, 510, 511, 512, 513, -1, -1, 292, -1, -1, + 295, -1, -1, -1, 394, -1, 8, -1, -1, 11, + -1, 177, -1, 15, 16, 17, 18, 19, 20, 21, + -1, -1, -1, -1, -1, -1, -1, -1, 194, -1, + -1, -1, -1, 199, 36, -1, -1, -1, -1, -1, + 337, 338, -1, -1, 46, -1, -1, -1, -1, -1, + -1, 53, -1, -1, -1, -1, 222, 223, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 237, -1, -1, -1, -1, -1, -1, 80, -1, + -1, 378, 379, -1, -1, -1, -1, -1, -1, 8, + -1, -1, 11, -1, -1, -1, 15, 16, -1, 394, + 19, 20, 21, -1, -1, -1, -1, -1, -1, 275, + -1, 501, 278, -1, 504, 505, 506, 36, 508, 509, + 510, 511, 512, 513, -1, -1, 292, 46, -1, 295, + -1, -1, -1, -1, 53, -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, 80, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 46, 177, 473, 474, -1, -1, + -1, 53, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 194, -1, -1, -1, -1, 199, -1, -1, + 497, 498, -1, -1, -1, -1, 501, -1, 80, 504, + 505, 506, -1, 508, 509, 510, 511, 512, 513, -1, + 222, 223, -1, -1, -1, -1, -1, -1, 394, -1, + -1, -1, -1, -1, -1, 237, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 177, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 275, -1, 194, 278, -1, -1, -1, + 199, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 292, -1, -1, 295, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 222, 223, 177, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 237, -1, + -1, -1, 194, -1, -1, -1, -1, 199, -1, -1, + -1, -1, -1, -1, -1, 501, -1, -1, 504, 505, + 506, -1, 508, 509, 510, 511, 512, 513, -1, -1, + 222, 223, -1, -1, -1, -1, 275, -1, -1, 278, + -1, -1, -1, -1, -1, 237, -1, -1, -1, -1, + -1, -1, -1, 292, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 394, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 275, -1, -1, 278, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 292, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 394, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 501, + -1, -1, 504, 505, 506, -1, 508, 509, 510, 511, + 512, 513, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 394, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 501, -1, -1, 504, 505, 506, -1, 508, + 509, 510, 511, 512, 513, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, - 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, - 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, - 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, - 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, - -1, -1, 83, 84, 85, 86, 87, 88, -1, 90, - 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, - -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, - 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, - 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, - 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, -1, - 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, - -1, -1, -1, 174, 175, 176, -1, 178, -1, 180, - -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, - 191, 192, 193, -1, 195, 196, 197, 198, -1, 200, - 201, 202, 203, 204, 205, 206, -1, 208, -1, 210, - 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, - 221, -1, -1, 224, -1, 226, 227, 228, 229, 230, - 231, -1, -1, 234, -1, 236, -1, -1, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, -1, 270, - 271, 272, 273, 274, -1, 276, 277, -1, 279, -1, - 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, - 291, 292, 293, 294, -1, -1, 297, 298, 299, -1, - 301, -1, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, - 321, -1, 323, 324, 325, 326, 327, 328, -1, 330, - 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - -1, 362, 363, -1, 365, 366, 367, 368, 369, 370, - 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, - 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, - 391, 392, -1, -1, 395, 396, 397, 398, -1, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, - -1, 422, 423, 424, 425, 426, -1, 428, 429, 430, - -1, -1, 433, 434, 435, 436, 437, -1, 439, 440, - 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, - 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, - 461, 462, 463, 464, -1, 466, -1, 468, 469, 470, - 471, 472, 473, 474, -1, -1, 477, -1, -1, 480, - 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, - 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, - 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, 159, -1, 161, -1, - 163, 164, 165, 166, -1, 168, -1, 170, -1, -1, - -1, 174, 175, 176, -1, 178, -1, 180, -1, 182, - 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, - 193, -1, 195, 196, 197, 198, -1, 200, 201, 202, - 203, 204, 205, 206, -1, 208, -1, 210, 211, 212, - 213, 214, 215, 216, 217, -1, 219, -1, 221, -1, - -1, 224, -1, 226, 227, 228, 229, 230, 231, -1, - -1, 234, -1, 236, -1, -1, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, -1, 270, 271, 272, - 273, 274, -1, 276, 277, -1, 279, -1, 281, 282, - 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, - 293, 294, -1, -1, 297, 298, 299, -1, 301, -1, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, -1, -1, -1, -1, 319, 320, 321, -1, - 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, - 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, - 363, -1, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, - -1, 384, 385, 386, 387, 388, 389, 390, 391, 392, - -1, -1, 395, 396, 397, 398, -1, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, -1, -1, 417, 418, -1, 420, -1, 422, - 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, - 433, 434, 435, 436, 437, -1, 439, 440, 441, 442, - 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, - 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, - 463, 464, -1, 466, -1, 468, 469, 470, 471, 472, - 473, 474, -1, -1, 477, -1, -1, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 498, 499, 500, 3, -1, - 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, - 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, - -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, - -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, - -1, -1, 67, 68, 69, 70, 71, 72, 73, -1, - 75, 76, 77, 78, 79, -1, -1, -1, 83, 84, - 85, 86, 87, 88, -1, 90, 91, 92, -1, 94, - 95, 96, 97, 98, 99, -1, -1, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, - 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, - 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, - 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, -1, 161, -1, 163, 164, - 165, 166, -1, 168, -1, 170, -1, -1, -1, 174, - 175, 176, -1, 178, -1, 180, -1, 182, 183, 184, - 185, -1, 187, 188, 189, 190, 191, 192, 193, -1, - 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, - 205, 206, -1, 208, -1, 210, 211, 212, 213, 214, - 215, 216, 217, -1, 219, -1, 221, -1, -1, 224, - -1, 226, 227, 228, 229, 230, 231, -1, -1, 234, - -1, 236, -1, -1, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, -1, 270, 271, 272, 273, 274, - -1, 276, 277, -1, 279, -1, 281, 282, 283, 284, - 285, 286, -1, 288, 289, -1, 291, 292, 293, 294, - -1, -1, 297, 298, 299, -1, 301, -1, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - -1, -1, -1, -1, 319, 320, 321, -1, 323, 324, - 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, - 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, - 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, -1, 362, 363, -1, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, - 385, 386, 387, 388, 389, 390, 391, 392, -1, -1, - 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, - -1, -1, 417, 418, -1, 420, -1, 422, 423, 424, - 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, - 435, 436, 437, -1, 439, 440, 441, 442, 443, 444, - 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, - 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, - -1, 466, -1, 468, 469, 470, 471, 472, 473, 474, - -1, -1, 477, -1, -1, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 499, 500, 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, 159, -1, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, -1, -1, -1, 174, 175, 176, - -1, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, -1, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, -1, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, -1, -1, 224, -1, 226, - 227, 228, 229, 230, 231, -1, -1, 234, -1, 236, - -1, -1, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, -1, 270, 271, 272, 273, 274, -1, 276, - 277, -1, 279, -1, 281, 282, 283, 284, 285, 286, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, -1, 301, -1, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, -1, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, -1, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, -1, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, -1, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, -1, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, -1, 466, - -1, 468, 469, 470, 471, 472, 473, 474, -1, -1, - 477, -1, -1, 480, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, - 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 43, 44, -1, 46, 47, 48, - -1, 50, 51, 52, 53, 54, -1, 56, 57, -1, - 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, - 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, - 79, -1, -1, -1, 83, 84, 85, 86, 87, 88, - -1, 90, 91, 92, -1, 94, 95, 96, 97, 98, - 99, -1, -1, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, - -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, - 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, - -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, - 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, -1, 161, -1, 163, 164, 165, 166, -1, 168, - -1, 170, -1, -1, -1, 174, 175, 176, -1, 178, - -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, - 189, 190, 191, 192, 193, -1, 195, 196, 197, 198, - -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, - -1, 210, 211, 212, 213, 214, 215, 216, 217, -1, - 219, -1, 221, -1, -1, 224, -1, 226, 227, 228, - 229, 230, 231, -1, -1, 234, -1, 236, -1, -1, - 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - -1, 270, 271, 272, 273, 274, -1, 276, 277, -1, - 279, -1, 281, 282, 283, 284, 285, 286, -1, 288, - 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, - 299, -1, 301, -1, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, - 319, 320, 321, -1, 323, 324, 325, 326, 327, 328, - -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, - 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, -1, 362, 363, -1, 365, 366, 367, 368, - 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, - 379, 380, 381, -1, -1, 384, 385, 386, 387, 388, - 389, 390, 391, 392, -1, -1, 395, 396, 397, 398, - -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, - 419, 420, -1, 422, 423, 424, 425, 426, -1, 428, - 429, 430, -1, -1, 433, 434, 435, 436, 437, -1, - 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, - 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, - 459, 460, 461, 462, 463, 464, -1, 466, -1, 468, - 469, 470, 471, 472, 473, 474, -1, -1, 477, -1, - -1, 480, 481, 482, 483, 484, 485, 486, 487, 488, - 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, - 499, 500, 3, -1, 5, -1, -1, -1, -1, -1, + -1, -1, -1, 3, -1, 5, -1, -1, -1, 501, + -1, -1, 504, 505, 506, -1, 508, 509, 510, 511, + 512, 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, 498, 499, + 500, 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, 498, 499, 500, 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, 498, 499, 500, 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, 498, 499, 500, 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, + 498, 499, 500, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, - 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, - 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, - 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, - 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, - -1, -1, 83, 84, 85, 86, 87, 88, -1, 90, - 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, - -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, - 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, - 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, - 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, -1, - 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, - -1, -1, -1, 174, 175, 176, -1, 178, -1, 180, - -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, - 191, 192, 193, -1, 195, 196, 197, 198, -1, 200, - 201, 202, 203, 204, 205, 206, -1, 208, -1, 210, - 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, - 221, -1, -1, 224, -1, 226, 227, 228, 229, 230, - 231, -1, -1, 234, -1, 236, -1, -1, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, -1, 270, - 271, 272, 273, 274, -1, 276, 277, -1, 279, -1, - 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, - -1, 292, 293, 294, -1, -1, 297, 298, 299, -1, - 301, -1, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, - 321, -1, 323, 324, 325, 326, 327, 328, -1, 330, - 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - -1, 362, 363, -1, 365, 366, 367, 368, 369, 370, - 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, - 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, - 391, 392, -1, -1, 395, 396, 397, 398, -1, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, - -1, 422, 423, 424, 425, 426, -1, 428, 429, 430, - -1, -1, 433, 434, 435, 436, 437, -1, 439, 440, - 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, - 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, - 461, 462, 463, 464, -1, 466, -1, 468, 469, 470, - 471, 472, 473, 474, -1, -1, 477, -1, -1, 480, - 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, - 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, - 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, - 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, - 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, - 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, - 63, 64, -1, -1, 67, 68, 69, 70, 71, 72, - 73, -1, 75, 76, 77, 78, 79, -1, -1, -1, - 83, 84, 85, 86, 87, 88, -1, 90, 91, 92, - -1, 94, 95, 96, 97, 98, 99, -1, -1, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, - 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, - -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, - -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, -1, 161, -1, - 163, 164, 165, 166, -1, 168, -1, 170, -1, -1, - -1, 174, 175, 176, -1, 178, -1, 180, -1, 182, - 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, - 193, -1, 195, 196, 197, 198, -1, 200, 201, 202, - 203, 204, 205, 206, -1, 208, -1, 210, 211, 212, - 213, 214, 215, 216, 217, -1, 219, -1, 221, -1, - -1, 224, -1, 226, 227, 228, 229, 230, 231, -1, - -1, 234, -1, 236, -1, -1, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, -1, 270, 271, 272, - 273, 274, -1, 276, 277, -1, 279, -1, 281, 282, - 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, - 293, 294, -1, -1, 297, 298, 299, -1, 301, -1, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, -1, -1, -1, -1, 319, 320, 321, -1, - 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, - 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, - 363, -1, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, - -1, 384, 385, 386, 387, 388, 389, 390, 391, 392, - -1, -1, 395, 396, 397, 398, -1, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, -1, -1, 417, 418, -1, 420, -1, 422, - 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, - 433, 434, 435, 436, 437, -1, 439, 440, 441, 442, - 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, - 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, - 463, 464, -1, 466, -1, 468, 469, 470, 471, 472, - 473, 474, -1, -1, 477, -1, -1, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 498, 499, 500, 3, -1, + -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, + -1, 31, 32, 33, -1, -1, -1, 37, -1, -1, + -1, -1, 42, 43, 44, -1, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, + 60, 61, 62, 63, 64, -1, -1, 67, 68, 69, + 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, + -1, 81, -1, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, + -1, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, + 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, + 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, + 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, -1, 163, 164, 165, 166, -1, 168, -1, + 170, 171, -1, 173, 174, 175, 176, 177, 178, -1, + 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, -1, + 200, 201, 202, 203, 204, 205, 206, -1, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, + -1, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, -1, -1, 234, 235, 236, 237, -1, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, -1, 276, 277, 278, 279, + -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, + 290, -1, 292, 293, 294, -1, -1, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, -1, + 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, + 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, + 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, + 380, 381, -1, 383, 384, 385, 386, 387, 388, 389, + 390, 391, 392, -1, 394, 395, 396, 397, 398, -1, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, -1, -1, 417, 418, -1, + 420, 421, 422, 423, 424, 425, 426, -1, 428, 429, + 430, -1, -1, 433, 434, 435, 436, 437, 438, 439, + 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, + 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, + 460, 461, 462, 463, 464, -1, 466, 467, 468, 469, + 470, 471, 472, 473, 474, -1, -1, 477, -1, -1, + 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, + 500, 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, 159, -1, 161, + -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, + -1, 173, 174, 175, 176, 177, 178, -1, 180, -1, + 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, + 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + -1, -1, 234, 235, 236, 237, -1, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, -1, 276, 277, 278, 279, -1, 281, + 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, + 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, + 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, + -1, 383, 384, 385, 386, 387, 388, 389, 390, 391, + 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, -1, -1, 417, 418, -1, 420, 421, + 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, + -1, 433, 434, 435, 436, 437, -1, 439, 440, 441, + 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, + -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, + 462, 463, 464, -1, 466, 467, 468, 469, 470, 471, + 472, 473, 474, -1, -1, 477, -1, -1, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 498, 499, 500, 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, 30, 31, 32, 33, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, - -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, - -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, - -1, -1, 67, 68, 69, 70, 71, 72, 73, -1, - 75, 76, 77, 78, 79, -1, -1, -1, 83, 84, - 85, 86, 87, 88, -1, 90, 91, 92, -1, 94, - 95, 96, 97, 98, 99, -1, -1, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, - 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, - 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, - 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, -1, 161, -1, 163, 164, - 165, 166, -1, 168, -1, 170, -1, -1, -1, 174, - 175, 176, -1, 178, -1, 180, -1, 182, 183, 184, - 185, -1, 187, 188, 189, 190, 191, 192, 193, -1, - 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, - 205, 206, -1, 208, -1, 210, 211, 212, 213, 214, - 215, 216, 217, -1, 219, -1, 221, -1, -1, 224, - -1, 226, 227, 228, 229, 230, 231, -1, -1, 234, - -1, 236, -1, -1, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, -1, 270, 271, 272, 273, 274, - -1, 276, 277, -1, 279, -1, 281, 282, 283, 284, - 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, - -1, -1, 297, 298, 299, -1, 301, -1, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - -1, -1, -1, -1, 319, 320, 321, -1, 323, 324, - 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, - 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, - 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, -1, 362, 363, -1, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, - 385, 386, 387, 388, 389, 390, 391, 392, -1, -1, - 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, - -1, -1, 417, 418, -1, 420, -1, 422, 423, 424, - 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, - 435, 436, 437, -1, 439, 440, 441, 442, 443, 444, - 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, - 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, - -1, 466, -1, 468, 469, 470, 471, 472, 473, 474, - -1, -1, 477, -1, -1, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 499, 500, 3, -1, 5, -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, 159, -1, 161, -1, 163, + 164, 165, 166, -1, 168, -1, 170, 171, -1, 173, + 174, 175, 176, 177, 178, -1, 180, -1, 182, 183, + 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, + 194, 195, 196, 197, 198, -1, 200, 201, 202, 203, + 204, 205, 206, -1, 208, 209, 210, 211, 212, 213, + 214, 215, 216, 217, -1, 219, -1, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, -1, -1, + 234, 235, 236, 237, -1, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, + 274, -1, 276, 277, 278, 279, -1, 281, 282, 283, + 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, + 294, -1, -1, 297, 298, 299, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, -1, -1, -1, -1, 319, 320, 321, 322, 323, + 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, + 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, + 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, + 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, + 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, + 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, + 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, + 414, -1, -1, 417, 418, -1, 420, 421, 422, 423, + 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, + 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, + 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, + 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, + 464, -1, 466, 467, 468, 469, 470, 471, 472, 473, + 474, -1, -1, 477, -1, -1, 480, 481, 482, 483, + 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 499, 500, 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, 159, -1, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, -1, -1, -1, 174, 175, 176, - -1, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, -1, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, -1, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, -1, -1, 224, -1, 226, - 227, 228, 229, 230, 231, -1, -1, 234, -1, 236, - -1, -1, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, -1, 270, 271, 272, 273, 274, -1, 276, - 277, -1, 279, -1, 281, 282, 283, 284, 285, 286, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, -1, 301, -1, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, -1, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, -1, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, -1, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, -1, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, -1, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, -1, 466, - -1, 468, 469, 470, 471, 472, 473, 474, -1, -1, - 477, -1, -1, 480, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 3, -1, 5, -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, 159, -1, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, 171, -1, 173, 174, 175, + 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, -1, -1, 234, 235, + 236, 237, -1, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, -1, + 276, 277, 278, 279, -1, 281, 282, 283, 284, 285, + 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, + -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, 394, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 436, 437, -1, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, -1, + 466, 467, 468, 469, 470, 471, 472, 473, 474, -1, + -1, 477, -1, -1, 480, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 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, 159, -1, 161, -1, 163, 164, 165, 166, -1, + 168, 169, 170, -1, -1, -1, 174, 175, 176, -1, + 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, + 188, 189, 190, 191, 192, 193, -1, 195, 196, 197, + 198, -1, 200, 201, 202, 203, 204, 205, 206, -1, + 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, + -1, 219, -1, 221, -1, -1, 224, -1, 226, 227, + 228, 229, 230, 231, -1, -1, 234, -1, 236, -1, + -1, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, -1, 270, 271, 272, 273, 274, -1, 276, 277, + -1, 279, -1, 281, 282, 283, 284, 285, 286, -1, + 288, 289, -1, -1, 292, 293, 294, -1, -1, 297, + 298, 299, -1, 301, -1, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, + -1, 319, 320, 321, -1, 323, 324, 325, 326, 327, + 328, 329, 330, 331, 332, 333, 334, 335, -1, 337, + 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, -1, 362, 363, -1, 365, 366, 367, + 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, + 378, 379, 380, 381, -1, -1, 384, 385, 386, 387, + 388, 389, 390, 391, 392, -1, -1, 395, 396, 397, + 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, + 408, 409, 410, 411, 412, 413, 414, -1, -1, 417, + 418, -1, 420, -1, 422, 423, 424, 425, 426, -1, + 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, + -1, 439, 440, 441, 442, 443, 444, 445, 446, -1, + 448, 449, 450, 451, -1, 453, 454, 455, 456, -1, + 458, 459, 460, 461, 462, 463, 464, -1, 466, -1, + 468, 469, 470, 471, 472, 473, 474, -1, -1, 477, + -1, -1, 480, 481, 482, 483, 484, 485, 486, 487, + 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, + 498, 499, 500, 3, -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, - 159, -1, 161, -1, 163, 164, 165, 166, -1, 168, - -1, 170, -1, -1, -1, 174, 175, 176, -1, 178, - -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, - 189, 190, 191, 192, 193, -1, 195, 196, 197, 198, - -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, - -1, 210, 211, 212, 213, 214, 215, 216, 217, -1, - 219, -1, 221, -1, -1, 224, -1, 226, 227, 228, - 229, 230, 231, -1, -1, 234, -1, 236, -1, -1, - 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - -1, 270, 271, 272, 273, 274, -1, 276, 277, -1, - 279, -1, 281, 282, 283, 284, 285, 286, -1, 288, - 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, - 299, -1, 301, -1, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, - 319, 320, 321, -1, 323, 324, 325, 326, 327, 328, - -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, - 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, -1, 362, 363, -1, 365, 366, 367, 368, - 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, - 379, 380, 381, -1, -1, 384, 385, 386, 387, 388, - 389, 390, 391, 392, -1, -1, 395, 396, 397, 398, - -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, - -1, 420, -1, 422, 423, 424, 425, 426, -1, 428, - 429, 430, -1, -1, 433, 434, 435, 436, 437, -1, - 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, - 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, - 459, 460, 461, 462, 463, 464, -1, 466, -1, 468, - 469, 470, 471, 472, 473, 474, -1, -1, 477, -1, - -1, 480, 481, 482, 483, 484, 485, 486, 487, 488, - 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, - 499, 500, 3, -1, 5, -1, -1, -1, -1, -1, + -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, + -1, 31, 32, 33, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, + 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, + 60, 61, 62, 63, 64, -1, -1, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + -1, -1, -1, 83, 84, 85, 86, 87, 88, -1, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, + -1, -1, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, + 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, + 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, + 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + -1, 161, -1, 163, 164, 165, 166, -1, 168, 169, + 170, -1, -1, -1, 174, 175, 176, -1, 178, -1, + 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, + 190, 191, 192, 193, -1, 195, 196, 197, 198, -1, + 200, 201, 202, 203, 204, 205, 206, -1, 208, -1, + 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, + -1, 221, -1, -1, 224, -1, 226, 227, 228, 229, + 230, 231, -1, -1, 234, -1, 236, 237, -1, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, -1, + 270, 271, 272, 273, 274, -1, 276, 277, -1, 279, + -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, + -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, + -1, 301, -1, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, + 320, 321, -1, 323, 324, 325, 326, 327, 328, 329, + 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, + 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, -1, 362, 363, -1, 365, 366, 367, 368, 369, + 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, + 380, 381, -1, -1, 384, 385, 386, 387, 388, 389, + 390, 391, 392, -1, -1, 395, 396, 397, 398, -1, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, -1, -1, 417, 418, -1, + 420, -1, 422, 423, 424, 425, 426, -1, 428, 429, + 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, + 440, 441, 442, 443, 444, 445, 446, -1, 448, 449, + 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, + 460, 461, 462, 463, 464, -1, 466, -1, 468, 469, + 470, 471, 472, 473, 474, -1, -1, 477, -1, -1, + 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, + 500, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, - 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, - 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, - 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, - 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, - -1, -1, 83, 84, 85, 86, 87, 88, -1, 90, - 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, - -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, - 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, - 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, - 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, -1, - 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, - -1, -1, -1, 174, 175, 176, -1, 178, -1, 180, - -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, - 191, 192, 193, -1, 195, 196, 197, 198, -1, 200, - 201, 202, 203, 204, 205, 206, -1, 208, -1, 210, - 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, - 221, -1, -1, 224, -1, 226, 227, 228, 229, 230, - 231, -1, -1, 234, -1, 236, -1, -1, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, -1, 270, - 271, 272, 273, 274, -1, 276, 277, -1, 279, -1, - 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, - -1, 292, 293, 294, -1, -1, 297, 298, 299, -1, - 301, -1, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, - 321, -1, 323, 324, 325, 326, 327, 328, -1, 330, - 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - -1, 362, 363, -1, 365, 366, 367, 368, 369, 370, - 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, - 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, - 391, 392, -1, -1, 395, 396, 397, 398, -1, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, - -1, 422, 423, 424, 425, 426, -1, 428, 429, 430, - -1, -1, 433, 434, 435, 436, 437, -1, 439, 440, - 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, - 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, - 461, 462, 463, 464, -1, 466, -1, 468, 469, 470, - 471, 472, 473, 474, -1, -1, 477, -1, -1, 480, - 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, - 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, - 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, - 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, - 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, - 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, - 63, 64, -1, -1, 67, 68, 69, 70, 71, 72, - 73, -1, 75, 76, 77, 78, 79, -1, -1, -1, - 83, 84, 85, 86, 87, 88, -1, 90, 91, 92, - -1, 94, 95, 96, 97, 98, 99, -1, -1, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, - 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, - -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, - -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, -1, 161, -1, - 163, 164, 165, 166, -1, 168, -1, 170, -1, -1, - -1, 174, 175, 176, -1, 178, -1, 180, -1, 182, - 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, - 193, -1, 195, 196, 197, 198, -1, 200, 201, 202, - 203, 204, 205, 206, -1, 208, -1, 210, 211, 212, - 213, 214, 215, 216, 217, -1, 219, -1, 221, -1, - -1, 224, -1, 226, 227, 228, 229, 230, 231, -1, - -1, 234, -1, 236, -1, -1, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, -1, 270, 271, 272, - 273, 274, -1, 276, 277, -1, 279, -1, 281, 282, - 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, - 293, 294, -1, -1, 297, 298, 299, -1, 301, -1, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, -1, -1, -1, -1, 319, 320, 321, -1, - 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, - 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, - 363, -1, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, - -1, 384, 385, 386, 387, 388, 389, 390, 391, 392, - -1, -1, 395, 396, 397, 398, -1, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, -1, -1, 417, 418, -1, 420, -1, 422, - 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, - 433, 434, 435, 436, 437, -1, 439, 440, 441, 442, - 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, - 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, - 463, 464, -1, 466, -1, 468, 469, 470, 471, 472, - 473, 474, -1, -1, 477, -1, -1, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 498, 499, 500, 3, -1, - 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, - 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, - -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, - -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, - -1, -1, 67, 68, 69, 70, 71, 72, 73, -1, - 75, 76, 77, 78, 79, -1, -1, -1, 83, 84, - 85, 86, 87, 88, -1, 90, 91, 92, -1, 94, - 95, 96, 97, 98, 99, -1, -1, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, - 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, - 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, - 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, -1, 161, -1, 163, 164, - 165, 166, -1, 168, -1, 170, -1, -1, -1, 174, - 175, 176, -1, 178, -1, 180, -1, 182, 183, 184, - 185, -1, 187, 188, 189, 190, 191, 192, 193, -1, - 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, - 205, 206, -1, 208, -1, 210, 211, 212, 213, 214, - 215, 216, 217, -1, 219, -1, 221, -1, -1, 224, - -1, 226, 227, 228, 229, 230, 231, -1, -1, 234, - -1, 236, -1, -1, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, -1, 270, 271, 272, 273, 274, - -1, 276, 277, -1, 279, -1, 281, 282, 283, 284, - 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, - -1, -1, 297, 298, 299, -1, 301, -1, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - -1, -1, -1, -1, 319, 320, 321, -1, 323, 324, - 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, - 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, - 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, -1, 362, 363, -1, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, - 385, 386, 387, 388, 389, 390, 391, 392, -1, -1, - 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, - -1, -1, 417, 418, -1, 420, -1, 422, 423, 424, - 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, - 435, 436, 437, -1, 439, 440, 441, 442, 443, 444, - 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, - 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, - -1, 466, -1, 468, 469, 470, 471, 472, 473, 474, - -1, -1, 477, -1, -1, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 499, 500, 3, -1, 5, -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, 159, -1, 161, + -1, 163, 164, 165, 166, -1, 168, -1, 170, -1, + -1, -1, 174, 175, 176, -1, 178, -1, 180, -1, + 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, + 192, 193, -1, 195, 196, 197, 198, -1, 200, 201, + 202, 203, 204, 205, 206, -1, 208, -1, 210, 211, + 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, + -1, -1, 224, -1, 226, 227, 228, 229, 230, 231, + -1, -1, 234, -1, 236, -1, -1, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, -1, 270, 271, + 272, 273, 274, -1, 276, 277, -1, 279, -1, 281, + 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, + 292, 293, 294, -1, -1, 297, 298, 299, -1, 301, + -1, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, + -1, 323, 324, 325, 326, 327, 328, -1, 330, 331, + 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, + 362, 363, -1, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, + -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, + 392, -1, -1, 395, 396, 397, 398, -1, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, -1, -1, 417, 418, -1, 420, -1, + 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, + -1, 433, 434, 435, 436, 437, -1, 439, 440, 441, + 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, + -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, + 462, 463, 464, -1, 466, -1, 468, 469, 470, 471, + 472, 473, 474, -1, -1, 477, -1, -1, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 498, 499, 500, 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, 159, -1, 161, -1, 163, + 164, 165, 166, -1, 168, -1, 170, -1, -1, -1, + 174, 175, 176, -1, 178, -1, 180, -1, 182, 183, + 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, + -1, 195, 196, 197, 198, -1, 200, 201, 202, 203, + 204, 205, 206, -1, 208, -1, 210, 211, 212, 213, + 214, 215, 216, 217, -1, 219, -1, 221, -1, -1, + 224, -1, 226, 227, 228, 229, 230, 231, -1, -1, + 234, -1, 236, -1, -1, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, -1, 270, 271, 272, 273, + 274, -1, 276, 277, -1, 279, -1, 281, 282, 283, + 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, + 294, -1, -1, 297, 298, 299, -1, 301, -1, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, -1, -1, -1, -1, 319, 320, 321, -1, 323, + 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, + 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, + 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, + -1, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, + 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, + -1, 395, 396, 397, 398, -1, 400, 401, 402, 403, + 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, + 414, -1, -1, 417, 418, -1, 420, -1, 422, 423, + 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, + 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, + 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, + 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, + 464, -1, 466, -1, 468, 469, 470, 471, 472, 473, + 474, -1, -1, 477, -1, -1, 480, 481, 482, 483, + 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 499, 500, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, - 47, 48, -1, 50, 51, 52, 53, 54, -1, 56, - 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, -1, -1, 83, 84, 85, 86, - 87, 88, -1, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, -1, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, -1, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, -1, -1, -1, 174, 175, 176, - -1, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, -1, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, -1, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, -1, -1, 224, -1, 226, - 227, 228, 229, 230, 231, -1, -1, 234, -1, 236, - -1, -1, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, -1, 270, 271, 272, 273, 274, -1, 276, - 277, -1, 279, -1, 281, 282, 283, 284, 285, 286, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, -1, 301, -1, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, -1, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, -1, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, -1, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, -1, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, -1, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, -1, 466, - -1, 468, 469, 470, 471, 472, 473, 474, -1, -1, - 477, -1, -1, 480, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 3, -1, 5, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, + 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, + 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, + -1, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, -1, -1, 83, 84, 85, + 86, 87, 88, -1, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, -1, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, + -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, + 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, -1, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, -1, -1, -1, 174, 175, + 176, -1, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, -1, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, -1, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, -1, -1, 224, -1, + 226, 227, 228, 229, 230, 231, -1, -1, 234, -1, + 236, -1, -1, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, -1, 270, 271, 272, 273, 274, -1, + 276, 277, -1, 279, -1, 281, 282, 283, 284, 285, + 286, -1, 288, 289, -1, 291, 292, 293, 294, -1, + -1, 297, 298, 299, -1, 301, -1, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, -1, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, -1, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, -1, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, -1, 420, -1, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 436, 437, -1, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, -1, + 466, -1, 468, 469, 470, 471, 472, 473, 474, -1, + -1, 477, -1, -1, 480, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, - 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 43, 44, -1, 46, 47, 48, - -1, 50, 51, 52, 53, 54, -1, 56, 57, -1, - 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, - 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, - 79, -1, -1, -1, 83, 84, 85, 86, 87, 88, - -1, 90, 91, 92, -1, 94, 95, 96, 97, 98, - 99, -1, -1, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, - -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, - 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, - -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, - 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, -1, 161, -1, 163, 164, 165, 166, -1, 168, - -1, 170, -1, -1, -1, 174, 175, 176, -1, 178, - -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, - 189, 190, 191, 192, 193, -1, 195, 196, 197, 198, - -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, - -1, 210, 211, 212, 213, 214, 215, 216, 217, -1, - 219, -1, 221, -1, -1, 224, -1, 226, 227, 228, - 229, 230, 231, -1, -1, 234, -1, 236, -1, -1, - 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - -1, 270, 271, 272, 273, 274, -1, 276, 277, -1, - 279, -1, 281, 282, 283, 284, 285, 286, -1, 288, - 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, - 299, -1, 301, -1, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, - 319, 320, 321, -1, 323, 324, 325, 326, 327, 328, - -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, - 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, -1, 362, 363, -1, 365, 366, 367, 368, - 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, - 379, 380, 381, -1, -1, 384, 385, 386, 387, 388, - 389, 390, 391, 392, -1, -1, 395, 396, 397, 398, - -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, - -1, 420, -1, 422, 423, 424, 425, 426, -1, 428, - 429, 430, -1, -1, 433, 434, 435, 436, 437, -1, - 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, - 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, - 459, 460, 461, 462, 463, 464, -1, 466, -1, 468, - 469, 470, 471, 472, 473, 474, -1, -1, 477, -1, - -1, 480, 481, 482, 483, 484, 485, 486, 487, 488, - 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, - 499, 500, 3, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, + 28, 29, -1, 31, 32, 33, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 43, 44, -1, 46, 47, + 48, -1, 50, 51, 52, 53, 54, -1, 56, 57, + -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, + 68, 69, 70, 71, 72, 73, -1, 75, 76, 77, + 78, 79, -1, -1, -1, 83, 84, 85, 86, 87, + 88, -1, 90, 91, 92, -1, 94, 95, 96, 97, + 98, 99, -1, -1, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, + 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, + 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, + 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, -1, 161, -1, 163, 164, 165, 166, -1, + 168, -1, 170, -1, -1, -1, 174, 175, 176, -1, + 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, + 188, 189, 190, 191, 192, 193, -1, 195, 196, 197, + 198, -1, 200, 201, 202, 203, 204, 205, 206, -1, + 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, + -1, 219, -1, 221, -1, -1, 224, -1, 226, 227, + 228, 229, 230, 231, -1, -1, 234, -1, 236, -1, + -1, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, -1, 270, 271, 272, 273, 274, -1, 276, 277, + -1, 279, -1, 281, 282, 283, 284, 285, 286, -1, + 288, 289, -1, 291, 292, 293, 294, -1, -1, 297, + 298, 299, -1, 301, -1, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, + -1, 319, 320, 321, -1, 323, 324, 325, 326, 327, + 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, + 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, -1, 362, 363, -1, 365, 366, 367, + 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, + 378, 379, 380, 381, -1, -1, 384, 385, 386, 387, + 388, 389, 390, 391, 392, -1, -1, 395, 396, 397, + 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, + 408, 409, 410, 411, 412, 413, 414, -1, -1, 417, + 418, -1, 420, -1, 422, 423, 424, 425, 426, -1, + 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, + -1, 439, 440, 441, 442, 443, 444, 445, 446, -1, + -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, + 458, 459, 460, 461, 462, 463, 464, -1, 466, -1, + 468, 469, 470, 471, 472, 473, 474, -1, -1, 477, + -1, -1, 480, 481, 482, 483, 484, 485, 486, 487, + 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, + 498, 499, 500, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, - 31, 32, 33, -1, -1, -1, -1, -1, -1, 40, - -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, - 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, - 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, - 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, - -1, -1, 83, 84, 85, 86, 87, 88, -1, 90, - 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, - -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, - 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, - 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, - 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, -1, - 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, - -1, -1, -1, 174, 175, 176, -1, 178, -1, 180, - -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, - 191, 192, 193, -1, 195, 196, 197, 198, -1, 200, - 201, 202, 203, 204, 205, 206, -1, 208, -1, 210, - 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, - 221, -1, -1, 224, -1, 226, 227, 228, 229, 230, - 231, -1, -1, 234, -1, 236, -1, -1, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, -1, 270, - 271, 272, 273, 274, -1, 276, 277, -1, 279, -1, - 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, - -1, 292, 293, 294, -1, -1, 297, 298, 299, -1, - 301, -1, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, - 321, -1, 323, 324, 325, 326, 327, 328, -1, 330, - 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - -1, 362, 363, -1, 365, 366, 367, 368, 369, 370, - 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, - 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, - 391, 392, -1, -1, 395, 396, 397, 398, -1, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, - -1, 422, 423, 424, 425, 426, -1, 428, 429, 430, - -1, -1, 433, 434, 435, 436, 437, -1, 439, 440, - 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, - 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, - 461, 462, 463, 464, -1, 466, -1, 468, 469, 470, - 471, 472, 473, 474, -1, -1, 477, -1, -1, 480, - 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, - 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, - 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, - 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, - 33, -1, -1, -1, -1, -1, -1, 40, -1, -1, - 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, - 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, - 63, 64, -1, -1, 67, 68, 69, 70, 71, 72, - 73, -1, 75, 76, 77, 78, 79, -1, -1, -1, - 83, 84, 85, 86, 87, 88, -1, 90, 91, 92, - -1, 94, 95, 96, 97, 98, 99, -1, -1, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, - 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, - -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, - -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, -1, 161, -1, - 163, 164, 165, 166, -1, 168, -1, 170, -1, -1, - -1, 174, 175, 176, -1, 178, -1, 180, -1, 182, - 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, - 193, -1, 195, 196, 197, 198, -1, 200, 201, 202, - 203, 204, 205, 206, -1, 208, -1, 210, 211, 212, - 213, 214, 215, 216, 217, -1, 219, -1, 221, -1, - -1, 224, -1, 226, 227, 228, 229, 230, 231, -1, - -1, 234, -1, 236, -1, -1, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, -1, 270, 271, 272, - 273, 274, -1, 276, 277, -1, 279, -1, 281, 282, - 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, - 293, 294, -1, -1, 297, 298, 299, -1, 301, -1, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, -1, -1, -1, -1, 319, 320, 321, -1, - 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, - 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, - 363, -1, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, - -1, 384, 385, 386, 387, 388, 389, 390, 391, 392, - -1, -1, 395, 396, 397, 398, -1, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, -1, -1, 417, 418, -1, 420, -1, 422, - 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, - 433, 434, 435, 436, 437, -1, 439, 440, 441, 442, - 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, - 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, - 463, 464, -1, 466, -1, 468, 469, 470, 471, 472, - 473, 474, -1, -1, 477, -1, -1, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 498, 499, 500, 3, -1, + -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, + 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, + 60, 61, 62, 63, 64, -1, -1, 67, 68, 69, + 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, + -1, -1, -1, 83, 84, 85, 86, 87, 88, -1, + 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, + -1, -1, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, + 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, + 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, + 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + -1, 161, -1, 163, 164, 165, 166, -1, 168, -1, + 170, -1, -1, -1, 174, 175, 176, -1, 178, -1, + 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, + 190, 191, 192, 193, -1, 195, 196, 197, 198, -1, + 200, 201, 202, 203, 204, 205, 206, -1, 208, -1, + 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, + -1, 221, -1, -1, 224, -1, 226, 227, 228, 229, + 230, 231, -1, -1, 234, -1, 236, -1, -1, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, -1, + 270, 271, 272, 273, 274, -1, 276, 277, -1, 279, + -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, + -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, + -1, 301, -1, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, + 320, 321, -1, 323, 324, 325, 326, 327, 328, -1, + 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, + 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, -1, 362, 363, -1, 365, 366, 367, 368, 369, + 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, + 380, 381, -1, -1, 384, 385, 386, 387, 388, 389, + 390, 391, 392, -1, -1, 395, 396, 397, 398, -1, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, -1, -1, 417, 418, -1, + 420, -1, 422, 423, 424, 425, 426, -1, 428, 429, + 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, + 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, + 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, + 460, 461, 462, 463, 464, -1, 466, -1, 468, 469, + 470, 471, 472, 473, 474, -1, -1, 477, -1, -1, + 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, + 500, 3, -1, 5, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, + 32, 33, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, + 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, + 62, 63, 64, -1, -1, 67, 68, 69, 70, 71, + 72, 73, -1, 75, 76, 77, 78, 79, -1, -1, + -1, 83, 84, 85, 86, 87, 88, -1, 90, 91, + 92, -1, 94, 95, 96, 97, 98, 99, -1, -1, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, + 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, + -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, + 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, -1, 161, + -1, 163, 164, 165, 166, -1, 168, -1, 170, -1, + -1, -1, 174, 175, 176, -1, 178, -1, 180, -1, + 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, + 192, 193, -1, 195, 196, 197, 198, -1, 200, 201, + 202, 203, 204, 205, 206, -1, 208, -1, 210, 211, + 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, + -1, -1, 224, -1, 226, 227, 228, 229, 230, 231, + -1, -1, 234, -1, 236, -1, -1, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, -1, 270, 271, + 272, 273, 274, -1, 276, 277, -1, 279, -1, 281, + 282, 283, 284, 285, 286, -1, 288, 289, -1, 291, + 292, 293, 294, -1, -1, 297, 298, 299, -1, 301, + -1, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, + -1, 323, 324, 325, 326, 327, 328, -1, 330, 331, + 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, + 362, 363, -1, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, + -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, + 392, -1, -1, 395, 396, 397, 398, -1, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, -1, -1, 417, 418, -1, 420, -1, + 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, + -1, 433, 434, 435, 436, 437, -1, 439, 440, 441, + 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, + -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, + 462, 463, 464, -1, 466, -1, 468, 469, 470, 471, + 472, 473, 474, -1, -1, 477, -1, -1, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 498, 499, 500, 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, 159, -1, 161, -1, 163, + 164, 165, 166, -1, 168, -1, 170, -1, -1, -1, + 174, 175, 176, -1, 178, -1, 180, -1, 182, 183, + 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, + -1, 195, 196, 197, 198, -1, 200, 201, 202, 203, + 204, 205, 206, -1, 208, -1, 210, 211, 212, 213, + 214, 215, 216, 217, -1, 219, -1, 221, -1, -1, + 224, -1, 226, 227, 228, 229, 230, 231, -1, -1, + 234, -1, 236, -1, -1, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, -1, 270, 271, 272, 273, + 274, -1, 276, 277, -1, 279, -1, 281, 282, 283, + 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, + 294, -1, -1, 297, 298, 299, -1, 301, -1, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, -1, -1, -1, -1, 319, 320, 321, -1, 323, + 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, + 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, + 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, + -1, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, + 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, + -1, 395, 396, 397, 398, -1, 400, 401, 402, 403, + 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, + 414, -1, -1, 417, 418, -1, 420, -1, 422, 423, + 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, + 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, + 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, + 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, + 464, -1, 466, -1, 468, 469, 470, 471, 472, 473, + 474, -1, -1, 477, -1, -1, 480, 481, 482, 483, + 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 499, 500, 3, -1, 5, -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, 159, -1, 161, -1, 163, 164, - 165, 166, -1, 168, -1, 170, -1, -1, -1, 174, - 175, 176, -1, 178, -1, 180, -1, 182, 183, 184, - 185, -1, 187, 188, 189, 190, 191, 192, 193, -1, - 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, - 205, 206, -1, 208, -1, 210, 211, 212, 213, 214, - 215, 216, 217, -1, 219, -1, 221, -1, -1, 224, - -1, 226, 227, 228, 229, 230, 231, -1, -1, 234, - -1, 236, -1, -1, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, -1, 270, 271, 272, 273, 274, - -1, 276, 277, -1, 279, -1, 281, 282, 283, 284, - 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, - -1, -1, 297, 298, 299, -1, 301, -1, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - -1, -1, -1, -1, 319, 320, 321, -1, 323, 324, - 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, - 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, - 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, -1, 362, 363, -1, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, - 385, 386, 387, 388, 389, 390, 391, 392, -1, -1, - 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, - -1, -1, 417, 418, -1, 420, -1, 422, 423, 424, - 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, - 435, 436, 437, -1, 439, 440, 441, 442, 443, 444, - 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, - 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, - -1, 466, -1, 468, 469, 470, 471, 472, 473, 474, - -1, -1, 477, -1, -1, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 499, 500, 3, -1, 5, -1, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, + 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, + 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, + -1, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, -1, -1, 83, 84, 85, + 86, 87, 88, -1, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, -1, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, + -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, + 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, -1, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, -1, -1, -1, 174, 175, + 176, -1, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, -1, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, -1, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, -1, -1, 224, -1, + 226, 227, 228, 229, 230, 231, -1, -1, 234, -1, + 236, -1, -1, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, -1, 270, 271, 272, 273, 274, -1, + 276, 277, -1, 279, -1, 281, 282, 283, 284, 285, + 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, + -1, 297, 298, 299, -1, 301, -1, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, -1, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, -1, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, -1, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, 419, 420, -1, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 436, 437, -1, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, -1, + 466, -1, 468, 469, 470, 471, 472, 473, 474, -1, + -1, 477, -1, -1, 480, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, - 47, 48, -1, 50, 51, 52, 53, 54, -1, 56, - 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, -1, -1, 83, 84, 85, 86, - 87, 88, -1, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, -1, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, -1, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, -1, -1, -1, 174, 175, 176, - -1, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, -1, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, -1, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, -1, -1, 224, -1, 226, - 227, 228, 229, 230, 231, -1, -1, 234, -1, 236, - -1, -1, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, -1, 270, 271, 272, 273, 274, -1, 276, - 277, -1, 279, -1, 281, 282, 283, 284, 285, 286, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, -1, 301, -1, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, -1, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, -1, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, -1, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, -1, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, -1, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, -1, 466, - -1, 468, 469, 470, 471, 472, 473, 474, -1, -1, - 477, -1, -1, 480, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 3, -1, 5, -1, -1, -1, + -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, + 28, 29, -1, 31, 32, 33, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 43, 44, -1, 46, 47, + 48, -1, 50, 51, 52, 53, 54, -1, 56, 57, + -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, + 68, 69, 70, 71, 72, 73, -1, 75, 76, 77, + 78, 79, -1, -1, -1, 83, 84, 85, 86, 87, + 88, -1, 90, 91, 92, -1, 94, 95, 96, 97, + 98, 99, -1, -1, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, + 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, + 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, + 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, -1, 161, -1, 163, 164, 165, 166, -1, + 168, -1, 170, -1, -1, -1, 174, 175, 176, -1, + 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, + 188, 189, 190, 191, 192, 193, -1, 195, 196, 197, + 198, -1, 200, 201, 202, 203, 204, 205, 206, -1, + 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, + -1, 219, -1, 221, -1, -1, 224, -1, 226, 227, + 228, 229, 230, 231, -1, -1, 234, -1, 236, -1, + -1, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, -1, 270, 271, 272, 273, 274, -1, 276, 277, + -1, 279, -1, 281, 282, 283, 284, 285, 286, -1, + 288, 289, -1, -1, 292, 293, 294, -1, -1, 297, + 298, 299, -1, 301, -1, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, + -1, 319, 320, 321, -1, 323, 324, 325, 326, 327, + 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, + 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, -1, 362, 363, -1, 365, 366, 367, + 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, + 378, 379, 380, 381, -1, -1, 384, 385, 386, 387, + 388, 389, 390, 391, 392, -1, -1, 395, 396, 397, + 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, + 408, 409, 410, 411, 412, 413, 414, -1, -1, 417, + 418, -1, 420, -1, 422, 423, 424, 425, 426, -1, + 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, + -1, 439, 440, 441, 442, 443, 444, 445, 446, -1, + -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, + 458, 459, 460, 461, 462, 463, 464, -1, 466, -1, + 468, 469, 470, 471, 472, 473, 474, -1, -1, 477, + -1, -1, 480, 481, 482, 483, 484, 485, 486, 487, + 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, + 498, 499, 500, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, - 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 43, 44, -1, 46, 47, 48, - -1, 50, 51, 52, 53, 54, -1, 56, 57, -1, - 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, - 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, - 79, -1, -1, -1, 83, 84, 85, 86, 87, 88, - -1, 90, 91, 92, -1, 94, 95, 96, 97, 98, - 99, -1, -1, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, - -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, - 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, - -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, - 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, -1, 161, -1, 163, 164, 165, 166, -1, 168, - -1, 170, -1, -1, -1, 174, 175, 176, -1, 178, - -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, - 189, 190, 191, 192, 193, -1, 195, 196, 197, 198, - -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, - -1, 210, 211, 212, 213, 214, 215, 216, 217, -1, - 219, -1, 221, -1, -1, 224, -1, 226, 227, 228, - 229, 230, 231, -1, -1, 234, -1, 236, -1, -1, - 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - -1, 270, 271, 272, 273, 274, -1, 276, 277, -1, - 279, -1, 281, 282, 283, 284, 285, 286, -1, 288, - 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, - 299, -1, 301, -1, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, - 319, 320, 321, -1, 323, 324, 325, 326, 327, 328, - -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, - 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, -1, 362, 363, -1, 365, 366, 367, 368, - 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, - 379, 380, 381, -1, -1, 384, 385, 386, 387, 388, - 389, 390, 391, 392, -1, -1, 395, 396, 397, 398, - -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, - -1, 420, -1, 422, 423, 424, 425, 426, -1, 428, - 429, 430, -1, -1, 433, 434, 435, 436, 437, -1, - 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, - 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, - 459, 460, 461, 462, 463, 464, -1, 466, -1, 468, - 469, 470, 471, 472, 473, 474, -1, -1, 477, -1, - -1, 480, 481, 482, 483, 484, 485, 486, 487, 488, - 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, - 499, 500, 3, -1, 5, -1, -1, -1, -1, -1, + -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, + -1, 31, 32, 33, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, + 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, + 60, 61, 62, 63, 64, -1, -1, 67, 68, 69, + 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, + -1, -1, -1, 83, 84, 85, 86, 87, 88, -1, + 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, + -1, -1, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, + 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, + 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, + 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + -1, 161, -1, 163, 164, 165, 166, -1, 168, -1, + 170, -1, -1, -1, 174, 175, 176, -1, 178, -1, + 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, + 190, 191, 192, 193, -1, 195, 196, 197, 198, -1, + 200, 201, 202, 203, 204, 205, 206, -1, 208, -1, + 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, + -1, 221, -1, -1, 224, -1, 226, 227, 228, 229, + 230, 231, -1, -1, 234, -1, 236, -1, -1, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, -1, + 270, 271, 272, 273, 274, -1, 276, 277, -1, 279, + -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, + -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, + -1, 301, -1, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, + 320, 321, -1, 323, 324, 325, 326, 327, 328, -1, + 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, + 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, -1, 362, 363, -1, 365, 366, 367, 368, 369, + 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, + 380, 381, -1, -1, 384, 385, 386, 387, 388, 389, + 390, 391, 392, -1, -1, 395, 396, 397, 398, -1, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, -1, -1, 417, 418, -1, + 420, -1, 422, 423, 424, 425, 426, -1, 428, 429, + 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, + 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, + 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, + 460, 461, 462, 463, 464, -1, 466, -1, 468, 469, + 470, 471, 472, 473, 474, -1, -1, 477, -1, -1, + 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, + 500, 3, -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, 159, -1, - 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, - -1, -1, -1, 174, 175, 176, -1, 178, -1, 180, - -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, - 191, 192, 193, -1, 195, 196, 197, 198, -1, 200, - 201, 202, 203, 204, 205, 206, -1, 208, -1, 210, - 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, - 221, -1, -1, 224, -1, 226, 227, 228, 229, 230, - 231, -1, -1, 234, -1, 236, -1, -1, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, -1, 270, - 271, 272, 273, 274, -1, 276, 277, -1, 279, -1, - 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, - -1, 292, 293, 294, -1, -1, 297, 298, 299, -1, - 301, -1, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, - 321, -1, 323, 324, 325, 326, 327, 328, -1, 330, - 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - -1, 362, 363, -1, 365, 366, 367, 368, 369, 370, - 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, - 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, - 391, 392, -1, -1, 395, 396, 397, 398, -1, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, - -1, 422, 423, 424, 425, 426, -1, 428, 429, 430, - -1, -1, 433, 434, 435, 436, 437, -1, 439, 440, - 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, - 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, - 461, 462, 463, 464, -1, 466, -1, 468, 469, 470, - 471, 472, 473, 474, -1, -1, 477, -1, -1, 480, - 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, - 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, - 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, - 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, - 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, - 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, - 63, 64, -1, -1, 67, 68, 69, 70, 71, 72, - 73, -1, 75, 76, 77, 78, 79, -1, -1, -1, - 83, 84, 85, 86, 87, 88, -1, 90, 91, 92, - -1, 94, 95, 96, 97, 98, 99, -1, -1, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, - 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, - -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, - -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, -1, 161, -1, - 163, 164, 165, 166, -1, 168, -1, 170, -1, -1, - -1, 174, 175, 176, -1, 178, -1, 180, -1, 182, - 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, - 193, -1, 195, 196, 197, 198, -1, 200, 201, 202, - 203, 204, 205, 206, -1, 208, -1, 210, 211, 212, - 213, 214, 215, 216, 217, -1, 219, -1, 221, -1, - -1, 224, -1, 226, 227, 228, 229, 230, 231, -1, - -1, 234, -1, 236, -1, -1, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, -1, 270, 271, 272, - 273, 274, -1, 276, 277, -1, 279, -1, 281, 282, - 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, - 293, 294, -1, -1, 297, 298, 299, -1, 301, -1, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, -1, -1, -1, -1, 319, 320, 321, -1, - 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, - 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, - 363, -1, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, - -1, 384, 385, 386, 387, 388, 389, 390, 391, 392, - -1, -1, 395, 396, 397, 398, -1, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, -1, -1, 417, 418, -1, 420, -1, 422, - 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, - 433, 434, 435, 436, 437, -1, 439, 440, 441, 442, - 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, - 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, - 463, 464, -1, 466, -1, 468, 469, 470, 471, 472, - 473, 474, -1, -1, 477, -1, -1, 480, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 498, 499, 500, 3, -1, - 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, - 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, - -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, - -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, - -1, -1, 67, 68, 69, 70, 71, 72, 73, -1, - 75, 76, 77, 78, 79, -1, -1, -1, 83, 84, - 85, 86, 87, 88, -1, 90, 91, 92, -1, 94, - 95, 96, 97, 98, 99, -1, -1, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, - 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, - 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, - 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, -1, 161, -1, 163, 164, - 165, 166, -1, 168, -1, 170, -1, -1, -1, 174, - 175, 176, -1, 178, -1, 180, -1, 182, 183, 184, - 185, -1, 187, 188, 189, 190, 191, 192, 193, -1, - 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, - 205, 206, -1, 208, -1, 210, 211, 212, 213, 214, - 215, 216, 217, -1, 219, -1, 221, -1, -1, 224, - -1, 226, 227, 228, 229, 230, 231, -1, -1, 234, - -1, 236, -1, -1, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, -1, 270, 271, 272, 273, 274, - -1, 276, 277, -1, 279, -1, 281, 282, 283, 284, - 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, - -1, -1, 297, 298, 299, -1, 301, -1, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - -1, -1, -1, -1, 319, 320, 321, -1, 323, 324, - 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, - 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, - 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, -1, 362, 363, -1, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, - 385, 386, 387, 388, 389, 390, 391, 392, -1, -1, - 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, - -1, -1, 417, 418, -1, 420, -1, 422, 423, 424, - 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, - 435, 436, 437, -1, 439, 440, 441, 442, 443, 444, - 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, - 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, - -1, 466, -1, 468, 469, 470, 471, 472, 473, 474, - -1, -1, 477, -1, -1, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 499, 500, 3, -1, -1, -1, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, + 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, + 62, 63, 64, -1, -1, 67, 68, 69, 70, 71, + 72, 73, -1, 75, 76, 77, 78, 79, -1, -1, + -1, 83, 84, 85, 86, 87, 88, -1, 90, 91, + 92, -1, 94, 95, 96, 97, 98, 99, -1, -1, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, + 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, + -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, + 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, -1, 161, + -1, 163, 164, 165, 166, -1, 168, -1, 170, -1, + -1, -1, 174, 175, 176, -1, 178, -1, 180, -1, + 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, + 192, 193, -1, 195, 196, 197, 198, -1, 200, 201, + 202, 203, 204, 205, 206, -1, 208, -1, 210, 211, + 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, + -1, -1, 224, -1, 226, 227, 228, 229, 230, 231, + -1, -1, 234, -1, 236, -1, -1, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, -1, 270, 271, + 272, 273, 274, -1, 276, 277, -1, 279, -1, 281, + 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, + 292, 293, 294, -1, -1, 297, 298, 299, -1, 301, + -1, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, + -1, 323, 324, 325, 326, 327, 328, -1, 330, 331, + 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, + 362, 363, -1, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, + -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, + 392, -1, -1, 395, 396, 397, 398, -1, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, -1, -1, 417, 418, -1, 420, -1, + 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, + -1, 433, 434, 435, 436, 437, -1, 439, 440, 441, + 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, + -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, + 462, 463, 464, -1, 466, -1, 468, 469, 470, 471, + 472, 473, 474, -1, -1, 477, -1, -1, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 498, 499, 500, 3, + -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, + 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, + 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, + 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, + 64, -1, -1, 67, 68, 69, 70, 71, 72, 73, + -1, 75, 76, 77, 78, 79, -1, -1, -1, 83, + 84, 85, 86, 87, 88, -1, 90, 91, 92, -1, + 94, 95, 96, 97, 98, 99, -1, -1, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, + 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, + 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, + 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, -1, 161, -1, 163, + 164, 165, 166, -1, 168, -1, 170, -1, -1, -1, + 174, 175, 176, -1, 178, -1, 180, -1, 182, 183, + 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, + -1, 195, 196, 197, 198, -1, 200, 201, 202, 203, + 204, 205, 206, -1, 208, -1, 210, 211, 212, 213, + 214, 215, 216, 217, -1, 219, -1, 221, -1, -1, + 224, -1, 226, 227, 228, 229, 230, 231, -1, -1, + 234, -1, 236, -1, -1, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, -1, 270, 271, 272, 273, + 274, -1, 276, 277, -1, 279, -1, 281, 282, 283, + 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, + 294, -1, -1, 297, 298, 299, -1, 301, -1, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, -1, -1, -1, -1, 319, 320, 321, -1, 323, + 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, + 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, + 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, + -1, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, + 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, + -1, 395, 396, 397, 398, -1, 400, 401, 402, 403, + 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, + 414, -1, -1, 417, 418, -1, 420, -1, 422, 423, + 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, + 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, + 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, + 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, + 464, -1, 466, -1, 468, 469, 470, 471, 472, 473, + 474, -1, -1, 477, -1, -1, 480, 481, 482, 483, + 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 499, 500, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - 37, -1, -1, 40, -1, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, -1, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, -1, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, -1, 153, 154, 155, 156, - 157, 158, -1, -1, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, - 177, 178, -1, 180, -1, -1, -1, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, -1, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - 237, -1, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, -1, -1, 276, - 277, 278, 279, -1, -1, 282, 283, 284, 285, 286, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, -1, 300, 301, 302, -1, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, -1, 322, 323, 324, -1, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, 383, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, -1, -1, -1, - 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, -1, 436, - -1, -1, 439, 440, 441, 442, 443, 444, 445, 446, - 447, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, -1, 464, -1, 466, - 467, 468, 469, 470, 471, 472, 473, 474, -1, -1, - 477, -1, -1, 480, 481, 482, 483, 484, 485, 3, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, + 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, + 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, + -1, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, -1, -1, 83, 84, 85, + 86, 87, 88, -1, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, -1, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, + -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, + 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, -1, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, -1, -1, -1, 174, 175, + 176, -1, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, -1, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, -1, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, -1, -1, 224, -1, + 226, 227, 228, 229, 230, 231, -1, -1, 234, -1, + 236, -1, -1, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, -1, 270, 271, 272, 273, 274, -1, + 276, 277, -1, 279, -1, 281, 282, 283, 284, 285, + 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, + -1, 297, 298, 299, -1, 301, -1, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, -1, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, -1, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, -1, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, -1, 420, -1, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 436, 437, -1, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, -1, + 466, -1, 468, 469, 470, 471, 472, 473, 474, -1, + -1, 477, -1, -1, 480, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 3, -1, 5, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, + 28, 29, -1, 31, 32, 33, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 43, 44, -1, 46, 47, + 48, -1, 50, 51, 52, 53, 54, -1, 56, 57, + -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, + 68, 69, 70, 71, 72, 73, -1, 75, 76, 77, + 78, 79, -1, -1, -1, 83, 84, 85, 86, 87, + 88, -1, 90, 91, 92, -1, 94, 95, 96, 97, + 98, 99, -1, -1, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, + 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, + 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, + 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, -1, 161, -1, 163, 164, 165, 166, -1, + 168, -1, 170, -1, -1, -1, 174, 175, 176, -1, + 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, + 188, 189, 190, 191, 192, 193, -1, 195, 196, 197, + 198, -1, 200, 201, 202, 203, 204, 205, 206, -1, + 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, + -1, 219, -1, 221, -1, -1, 224, -1, 226, 227, + 228, 229, 230, 231, -1, -1, 234, -1, 236, -1, + -1, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, -1, 270, 271, 272, 273, 274, -1, 276, 277, + -1, 279, -1, 281, 282, 283, 284, 285, 286, -1, + 288, 289, -1, -1, 292, 293, 294, -1, -1, 297, + 298, 299, -1, 301, -1, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, + -1, 319, 320, 321, -1, 323, 324, 325, 326, 327, + 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, + 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, -1, 362, 363, -1, 365, 366, 367, + 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, + 378, 379, 380, 381, -1, -1, 384, 385, 386, 387, + 388, 389, 390, 391, 392, -1, -1, 395, 396, 397, + 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, + 408, 409, 410, 411, 412, 413, 414, -1, -1, 417, + 418, -1, 420, -1, 422, 423, 424, 425, 426, -1, + 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, + -1, 439, 440, 441, 442, 443, 444, 445, 446, -1, + -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, + 458, 459, 460, 461, 462, 463, 464, -1, 466, -1, + 468, 469, 470, 471, 472, 473, 474, -1, -1, 477, + -1, -1, 480, 481, 482, 483, 484, 485, 486, 487, + 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, + 498, 499, 500, 3, -1, 5, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, + -1, 31, 32, 33, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, + 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, + 60, 61, 62, 63, 64, -1, -1, 67, 68, 69, + 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, + -1, -1, -1, 83, 84, 85, 86, 87, 88, -1, + 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, + -1, -1, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, + 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, + 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, + 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + -1, 161, -1, 163, 164, 165, 166, -1, 168, -1, + 170, -1, -1, -1, 174, 175, 176, -1, 178, -1, + 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, + 190, 191, 192, 193, -1, 195, 196, 197, 198, -1, + 200, 201, 202, 203, 204, 205, 206, -1, 208, -1, + 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, + -1, 221, -1, -1, 224, -1, 226, 227, 228, 229, + 230, 231, -1, -1, 234, -1, 236, -1, -1, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, -1, + 270, 271, 272, 273, 274, -1, 276, 277, -1, 279, + -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, + -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, + -1, 301, -1, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, + 320, 321, -1, 323, 324, 325, 326, 327, 328, -1, + 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, + 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, -1, 362, 363, -1, 365, 366, 367, 368, 369, + 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, + 380, 381, -1, -1, 384, 385, 386, 387, 388, 389, + 390, 391, 392, -1, -1, 395, 396, 397, 398, -1, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, -1, -1, 417, 418, -1, + 420, -1, 422, 423, 424, 425, 426, -1, 428, 429, + 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, + 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, + 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, + 460, 461, 462, 463, 464, -1, 466, -1, 468, 469, + 470, 471, 472, 473, 474, -1, -1, 477, -1, -1, + 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, + 500, 3, -1, 5, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, + 32, 33, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, + 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, + 62, 63, 64, -1, -1, 67, 68, 69, 70, 71, + 72, 73, -1, 75, 76, 77, 78, 79, -1, -1, + -1, 83, 84, 85, 86, 87, 88, -1, 90, 91, + 92, -1, 94, 95, 96, 97, 98, 99, -1, -1, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, + 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, + -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, + 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, -1, 161, + -1, 163, 164, 165, 166, -1, 168, -1, 170, -1, + -1, -1, 174, 175, 176, -1, 178, -1, 180, -1, + 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, + 192, 193, -1, 195, 196, 197, 198, -1, 200, 201, + 202, 203, 204, 205, 206, -1, 208, -1, 210, 211, + 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, + -1, -1, 224, -1, 226, 227, 228, 229, 230, 231, + -1, -1, 234, -1, 236, -1, -1, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, -1, 270, 271, + 272, 273, 274, -1, 276, 277, -1, 279, -1, 281, + 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, + 292, 293, 294, -1, -1, 297, 298, 299, -1, 301, + -1, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, + -1, 323, 324, 325, 326, 327, 328, -1, 330, 331, + 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, + 362, 363, -1, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, + -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, + 392, -1, -1, 395, 396, 397, 398, -1, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, -1, -1, 417, 418, -1, 420, -1, + 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, + -1, 433, 434, 435, 436, 437, -1, 439, 440, 441, + 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, + -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, + 462, 463, 464, -1, 466, -1, 468, 469, 470, 471, + 472, 473, 474, -1, -1, 477, -1, -1, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 498, 499, 500, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, - 497, 498, 499, 500, -1, -1, -1, -1, 22, 23, + -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, @@ -16949,7 +17626,7 @@ static const yytype_int16 yycheck[] = 464, -1, 466, -1, 468, 469, 470, 471, 472, 473, 474, -1, -1, 477, -1, -1, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, - 494, 495, 496, 497, 498, 499, 500, 3, -1, -1, + 494, 495, 496, 497, 498, 499, 500, 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, @@ -17003,7 +17680,7 @@ static const yytype_int16 yycheck[] = -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 43, 44, -1, 46, 47, + -1, -1, 40, -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, 77, @@ -17053,7 +17730,7 @@ static const yytype_int16 yycheck[] = -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, + 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, @@ -17101,7 +17778,7 @@ static const yytype_int16 yycheck[] = 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 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, + 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, @@ -17149,7 +17826,7 @@ static const yytype_int16 yycheck[] = 472, 473, 474, -1, -1, 477, -1, -1, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 3, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, @@ -17175,329 +17852,827 @@ static const yytype_int16 yycheck[] = 234, -1, 236, -1, -1, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, - 264, 265, 266, 267, 268, -1, 270, 271, 272, 273, - 274, -1, 276, 277, -1, 279, -1, 281, 282, 283, + 264, 265, 266, 267, 268, -1, 270, 271, 272, 273, + 274, -1, 276, 277, -1, 279, -1, 281, 282, 283, + 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, + 294, -1, -1, 297, 298, 299, -1, 301, -1, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, -1, -1, -1, -1, 319, 320, 321, -1, 323, + 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, + 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, + 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, + -1, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, + 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, + -1, 395, 396, 397, 398, -1, 400, 401, 402, 403, + 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, + 414, -1, -1, 417, 418, -1, 420, -1, 422, 423, + 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, + 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, + 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, + 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, + 464, -1, 466, -1, 468, 469, 470, 471, 472, 473, + 474, -1, -1, 477, -1, -1, 480, 481, 482, 483, + 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 499, 500, 3, -1, 5, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, + 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, + 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, + -1, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, -1, -1, 83, 84, 85, + 86, 87, 88, -1, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, -1, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, + -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, + 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, -1, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, -1, -1, -1, 174, 175, + 176, -1, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, -1, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, -1, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, -1, -1, 224, -1, + 226, 227, 228, 229, 230, 231, -1, -1, 234, -1, + 236, -1, -1, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, -1, 270, 271, 272, 273, 274, -1, + 276, 277, -1, 279, -1, 281, 282, 283, 284, 285, + 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, + -1, 297, 298, 299, -1, 301, -1, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, -1, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, -1, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, -1, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, -1, 420, -1, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 436, 437, -1, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, -1, + 466, -1, 468, 469, 470, 471, 472, 473, 474, -1, + -1, 477, -1, -1, 480, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 3, -1, 5, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, + 28, 29, -1, 31, 32, 33, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 43, 44, -1, 46, 47, + 48, -1, 50, 51, 52, 53, 54, -1, 56, 57, + -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, + 68, 69, 70, 71, 72, 73, -1, 75, 76, 77, + 78, 79, -1, -1, -1, 83, 84, 85, 86, 87, + 88, -1, 90, 91, 92, -1, 94, 95, 96, 97, + 98, 99, -1, -1, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, + 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, + 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, + 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, -1, 161, -1, 163, 164, 165, 166, -1, + 168, -1, 170, -1, -1, -1, 174, 175, 176, -1, + 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, + 188, 189, 190, 191, 192, 193, -1, 195, 196, 197, + 198, -1, 200, 201, 202, 203, 204, 205, 206, -1, + 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, + -1, 219, -1, 221, -1, -1, 224, -1, 226, 227, + 228, 229, 230, 231, -1, -1, 234, -1, 236, -1, + -1, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, -1, 270, 271, 272, 273, 274, -1, 276, 277, + -1, 279, -1, 281, 282, 283, 284, 285, 286, -1, + 288, 289, -1, -1, 292, 293, 294, -1, -1, 297, + 298, 299, -1, 301, -1, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, + -1, 319, 320, 321, -1, 323, 324, 325, 326, 327, + 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, + 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, -1, 362, 363, -1, 365, 366, 367, + 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, + 378, 379, 380, 381, -1, -1, 384, 385, 386, 387, + 388, 389, 390, 391, 392, -1, -1, 395, 396, 397, + 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, + 408, 409, 410, 411, 412, 413, 414, -1, -1, 417, + 418, -1, 420, -1, 422, 423, 424, 425, 426, -1, + 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, + -1, 439, 440, 441, 442, 443, 444, 445, 446, -1, + -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, + 458, 459, 460, 461, 462, 463, 464, -1, 466, -1, + 468, 469, 470, 471, 472, 473, 474, -1, -1, 477, + -1, -1, 480, 481, 482, 483, 484, 485, 486, 487, + 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, + 498, 499, 500, 3, -1, 5, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, + -1, 31, 32, 33, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, + 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, + 60, 61, 62, 63, 64, -1, -1, 67, 68, 69, + 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, + -1, -1, -1, 83, 84, 85, 86, 87, 88, -1, + 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, + -1, -1, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, + 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, + 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, + 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + -1, 161, -1, 163, 164, 165, 166, -1, 168, -1, + 170, -1, -1, -1, 174, 175, 176, -1, 178, -1, + 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, + 190, 191, 192, 193, -1, 195, 196, 197, 198, -1, + 200, 201, 202, 203, 204, 205, 206, -1, 208, -1, + 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, + -1, 221, -1, -1, 224, -1, 226, 227, 228, 229, + 230, 231, -1, -1, 234, -1, 236, -1, -1, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, -1, + 270, 271, 272, 273, 274, -1, 276, 277, -1, 279, + -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, + -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, + -1, 301, -1, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, + 320, 321, -1, 323, 324, 325, 326, 327, 328, -1, + 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, + 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, -1, 362, 363, -1, 365, 366, 367, 368, 369, + 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, + 380, 381, -1, -1, 384, 385, 386, 387, 388, 389, + 390, 391, 392, -1, -1, 395, 396, 397, 398, -1, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, -1, -1, 417, 418, -1, + 420, -1, 422, 423, 424, 425, 426, -1, 428, 429, + 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, + 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, + 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, + 460, 461, 462, 463, 464, -1, 466, -1, 468, 469, + 470, 471, 472, 473, 474, -1, -1, 477, -1, -1, + 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, + 500, 3, -1, 5, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, + 32, 33, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, + 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, + 62, 63, 64, -1, -1, 67, 68, 69, 70, 71, + 72, 73, -1, 75, 76, 77, 78, 79, -1, -1, + -1, 83, 84, 85, 86, 87, 88, -1, 90, 91, + 92, -1, 94, 95, 96, 97, 98, 99, -1, -1, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, + 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, + -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, + 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, -1, 161, + -1, 163, 164, 165, 166, -1, 168, -1, 170, -1, + -1, -1, 174, 175, 176, -1, 178, -1, 180, -1, + 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, + 192, 193, -1, 195, 196, 197, 198, -1, 200, 201, + 202, 203, 204, 205, 206, -1, 208, -1, 210, 211, + 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, + -1, -1, 224, -1, 226, 227, 228, 229, 230, 231, + -1, -1, 234, -1, 236, -1, -1, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, -1, 270, 271, + 272, 273, 274, -1, 276, 277, -1, 279, -1, 281, + 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, + 292, 293, 294, -1, -1, 297, 298, 299, -1, 301, + -1, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, + -1, 323, 324, 325, 326, 327, 328, -1, 330, 331, + 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, + 362, 363, -1, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, + -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, + 392, -1, -1, 395, 396, 397, 398, -1, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, -1, -1, 417, 418, -1, 420, -1, + 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, + -1, 433, 434, 435, 436, 437, -1, 439, 440, 441, + 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, + -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, + 462, 463, 464, -1, 466, -1, 468, 469, 470, 471, + 472, 473, 474, -1, -1, 477, -1, -1, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 498, 499, 500, 3, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, + 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, + -1, -1, -1, 37, -1, -1, 40, -1, 42, 43, + 44, -1, 46, 47, 48, 49, 50, 51, 52, -1, + 54, 55, 56, 57, -1, 59, 60, 61, 62, 63, + 64, -1, -1, 67, 68, 69, 70, 71, 72, 73, + -1, 75, 76, 77, 78, -1, -1, 81, -1, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, -1, + 94, 95, 96, 97, 98, 99, -1, 101, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, + 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, + 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, + 144, 145, 146, -1, 148, 149, 150, 151, -1, 153, + 154, 155, 156, 157, 158, -1, -1, 161, -1, 163, + 164, 165, 166, -1, 168, -1, 170, 171, -1, 173, + 174, 175, 176, 177, 178, -1, 180, -1, -1, -1, + 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, + 194, 195, 196, 197, 198, -1, 200, 201, 202, 203, + 204, 205, 206, -1, 208, 209, -1, 211, 212, 213, + 214, 215, 216, 217, -1, 219, -1, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, -1, -1, + 234, 235, 236, 237, -1, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, + -1, -1, 276, 277, 278, 279, -1, -1, 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, - 294, -1, -1, 297, 298, 299, -1, 301, -1, 303, + 294, -1, -1, 297, 298, -1, 300, 301, 302, -1, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, -1, -1, -1, -1, 319, 320, 321, -1, 323, - 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, + 314, -1, -1, -1, -1, 319, 320, -1, 322, 323, + 324, -1, 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, - -1, 365, 366, 367, 368, 369, 370, 371, 372, 373, - 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, + 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 375, 376, 377, 378, 379, 380, 381, -1, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, - -1, 395, 396, 397, 398, -1, 400, 401, 402, 403, + 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, -1, -1, 417, 418, -1, 420, -1, 422, 423, + -1, -1, -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, - 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, - 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, - 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, - 464, -1, 466, -1, 468, 469, 470, 471, 472, 473, + 434, -1, 436, -1, -1, 439, 440, 441, 442, 443, + 444, 445, 446, 447, -1, 449, 450, 451, -1, 453, + 454, 455, 456, -1, 458, 459, 460, 461, 462, -1, + 464, -1, 466, 467, 468, 469, 470, 471, 472, 473, 474, -1, -1, 477, -1, -1, 480, 481, 482, 483, - 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, - 494, 495, 496, 497, 498, 499, 500, 3, -1, -1, + 484, 485, 3, -1, 5, -1, -1, -1, -1, -1, + -1, -1, -1, 497, 498, 499, 500, -1, -1, -1, + -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, + 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, + 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, + 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, + 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, + -1, -1, 83, 84, 85, 86, 87, 88, -1, 90, + 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, + -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, + 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, + 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, + 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, -1, + 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, + -1, -1, -1, 174, 175, 176, -1, 178, -1, 180, + -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, + 191, 192, 193, -1, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, -1, 210, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, -1, -1, 224, -1, 226, 227, 228, 229, 230, + 231, -1, -1, 234, -1, 236, -1, -1, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, -1, 270, + 271, 272, 273, 274, -1, 276, 277, -1, 279, -1, + 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, + -1, 292, 293, 294, -1, -1, 297, 298, 299, -1, + 301, -1, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, + 321, -1, 323, 324, 325, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, -1, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, + 391, 392, -1, -1, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, + -1, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, 435, 436, 437, -1, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, 463, 464, -1, 466, -1, 468, 469, 470, + 471, 472, 473, 474, -1, -1, 477, -1, -1, 480, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, + 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, + 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, + 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, + 63, 64, -1, -1, 67, 68, 69, 70, 71, 72, + 73, -1, 75, 76, 77, 78, 79, -1, -1, -1, + 83, 84, 85, 86, 87, 88, -1, 90, 91, 92, + -1, 94, 95, 96, 97, 98, 99, -1, -1, 102, + 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, + 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, + 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, + -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, + -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, + 153, 154, 155, 156, 157, 158, 159, -1, 161, -1, + 163, 164, 165, 166, -1, 168, -1, 170, -1, -1, + -1, 174, 175, 176, -1, 178, -1, 180, -1, 182, + 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, + 193, -1, 195, 196, 197, 198, -1, 200, 201, 202, + 203, 204, 205, 206, -1, 208, -1, 210, 211, 212, + 213, 214, 215, 216, 217, -1, 219, -1, 221, -1, + -1, 224, -1, 226, 227, 228, 229, 230, 231, -1, + -1, 234, -1, 236, -1, -1, 239, 240, 241, 242, + 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, + 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, + 263, 264, 265, 266, 267, 268, -1, 270, 271, 272, + 273, 274, -1, 276, 277, -1, 279, -1, 281, 282, + 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, + 293, 294, -1, -1, 297, 298, 299, -1, 301, -1, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, -1, -1, -1, -1, 319, 320, 321, -1, + 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, + 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, + 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, + 363, -1, 365, 366, 367, 368, 369, 370, 371, 372, + 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, + -1, 384, 385, 386, 387, 388, 389, 390, 391, 392, + -1, -1, 395, 396, 397, 398, -1, 400, 401, 402, + 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, + 413, 414, -1, -1, 417, 418, -1, 420, -1, 422, + 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, + 433, 434, 435, 436, 437, -1, 439, 440, 441, 442, + 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, + 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, + 463, 464, -1, 466, -1, 468, 469, 470, 471, 472, + 473, 474, -1, -1, 477, -1, -1, 480, 481, 482, + 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, + 493, 494, 495, 496, 497, 498, 499, 500, 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, 159, -1, 161, -1, 163, 164, 165, - 166, -1, 168, -1, 170, -1, -1, -1, 174, 175, - 176, -1, 178, -1, 180, -1, 182, 183, 184, 185, - -1, 187, 188, 189, 190, 191, 192, 193, -1, 195, - 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, - 206, -1, 208, -1, 210, 211, 212, 213, 214, 215, - 216, 217, -1, 219, -1, 221, -1, -1, 224, -1, - 226, 227, 228, 229, 230, 231, -1, -1, 234, -1, - 236, -1, -1, 239, 240, 241, 242, 243, 244, 245, - 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, - 266, 267, 268, -1, 270, 271, 272, 273, 274, -1, - 276, 277, -1, 279, -1, 281, 282, 283, 284, 285, - 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, - -1, 297, 298, 299, -1, 301, -1, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, - -1, -1, -1, 319, 320, 321, -1, 323, 324, 325, - 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, - -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, - 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, -1, 362, 363, -1, 365, - 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, - 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, - 386, 387, 388, 389, 390, 391, 392, -1, -1, 395, - 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, - -1, 417, 418, -1, 420, -1, 422, 423, 424, 425, - 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, - 436, 437, -1, 439, 440, 441, 442, 443, 444, 445, - 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, - 456, -1, 458, 459, 460, 461, 462, 463, 464, -1, - 466, -1, 468, 469, 470, 471, 472, 473, 474, -1, - -1, 477, -1, -1, 480, 481, 482, 483, 484, 485, - 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, - 496, 497, 498, 499, 500, 3, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, + 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, + -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, + -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, + -1, -1, 67, 68, 69, 70, 71, 72, 73, -1, + 75, 76, 77, 78, 79, -1, -1, -1, 83, 84, + 85, 86, 87, 88, -1, 90, 91, 92, -1, 94, + 95, 96, 97, 98, 99, -1, -1, 102, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, + 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, + 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, + 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, + 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, -1, 161, -1, 163, 164, + 165, 166, -1, 168, -1, 170, -1, -1, -1, 174, + 175, 176, -1, 178, -1, 180, -1, 182, 183, 184, + 185, -1, 187, 188, 189, 190, 191, 192, 193, -1, + 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, + 205, 206, -1, 208, -1, 210, 211, 212, 213, 214, + 215, 216, 217, -1, 219, -1, 221, -1, -1, 224, + -1, 226, 227, 228, 229, 230, 231, -1, -1, 234, + -1, 236, -1, -1, 239, 240, 241, 242, 243, 244, + 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, -1, 270, 271, 272, 273, 274, + -1, 276, 277, -1, 279, -1, 281, 282, 283, 284, + 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, + -1, -1, 297, 298, 299, -1, 301, -1, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + -1, -1, -1, -1, 319, 320, 321, -1, 323, 324, + 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, + 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, + 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, -1, 362, 363, -1, + 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, + 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, + 385, 386, 387, 388, 389, 390, 391, 392, -1, -1, + 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + -1, -1, 417, 418, -1, 420, -1, 422, 423, 424, + 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, + 435, 436, 437, -1, 439, 440, 441, 442, 443, 444, + 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, + 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, + -1, 466, -1, 468, 469, 470, 471, 472, 473, 474, + -1, -1, 477, -1, -1, 480, 481, 482, 483, 484, + 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, + 495, 496, 497, 498, 499, 500, 3, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, + 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, + 47, 48, -1, 50, 51, 52, 53, 54, -1, 56, + 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, + 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, + 77, 78, 79, -1, -1, -1, 83, 84, 85, 86, + 87, 88, -1, 90, 91, 92, -1, 94, 95, 96, + 97, 98, 99, -1, -1, 102, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, + -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, + -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, + 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, + -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, + 157, 158, 159, -1, 161, -1, 163, 164, 165, 166, + -1, 168, -1, 170, -1, -1, -1, 174, 175, 176, + -1, 178, -1, 180, -1, 182, 183, 184, 185, -1, + 187, 188, 189, 190, 191, 192, 193, -1, 195, 196, + 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, + -1, 208, -1, 210, 211, 212, 213, 214, 215, 216, + 217, -1, 219, -1, 221, -1, -1, 224, -1, 226, + 227, 228, 229, 230, 231, -1, -1, 234, -1, 236, + -1, -1, 239, 240, 241, 242, 243, 244, 245, 246, + 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, + 267, 268, -1, 270, 271, 272, 273, 274, -1, 276, + 277, -1, 279, -1, 281, 282, 283, 284, 285, 286, + -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, + 297, 298, 299, -1, 301, -1, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, + -1, -1, 319, 320, 321, -1, 323, 324, 325, 326, + 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, + 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, + -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 360, -1, 362, 363, -1, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, + 387, 388, 389, 390, 391, 392, -1, -1, 395, 396, + 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, + 417, 418, -1, 420, -1, 422, 423, 424, 425, 426, + -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, + 437, -1, 439, 440, 441, 442, 443, 444, 445, 446, + -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, + -1, 458, 459, 460, 461, 462, 463, 464, -1, 466, + -1, 468, 469, 470, 471, 472, 473, 474, -1, -1, + 477, -1, -1, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 498, 499, 500, 3, -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, 40, -1, -1, 43, 44, -1, 46, 47, - 48, -1, 50, 51, 52, 53, 54, -1, 56, 57, - -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, - 68, 69, 70, 71, 72, 73, -1, 75, 76, 77, - 78, 79, -1, -1, -1, 83, 84, 85, 86, 87, - 88, -1, 90, 91, 92, -1, 94, 95, 96, 97, - 98, 99, -1, -1, 102, 103, 104, 105, 106, 107, - 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, - 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, - 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, - 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, - 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, -1, 161, -1, 163, 164, 165, 166, -1, - 168, -1, 170, -1, -1, -1, 174, 175, 176, -1, - 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, - 188, 189, 190, 191, 192, 193, -1, 195, 196, 197, - 198, -1, 200, 201, 202, 203, 204, 205, 206, -1, - 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, - -1, 219, -1, 221, -1, -1, 224, -1, 226, 227, - 228, 229, 230, 231, -1, -1, 234, -1, 236, -1, - -1, 239, 240, 241, 242, 243, 244, 245, 246, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, -1, 270, 271, 272, 273, 274, -1, 276, 277, - -1, 279, -1, 281, 282, 283, 284, 285, 286, -1, - 288, 289, -1, -1, 292, 293, 294, -1, -1, 297, - 298, 299, -1, 301, -1, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, - -1, 319, 320, 321, -1, 323, 324, 325, 326, 327, - 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, - 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, -1, 362, 363, -1, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, 379, 380, 381, -1, -1, 384, 385, 386, 387, - 388, -1, 390, 391, 392, -1, -1, 395, 396, 397, - 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, 412, 413, 414, -1, -1, 417, - 418, -1, 420, -1, 422, 423, 424, 425, 426, -1, - 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, - -1, 439, 440, 441, 442, 443, 444, 445, 446, -1, - -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, - 458, 459, 460, 461, 462, 463, 464, -1, 466, -1, - 468, 469, 470, 471, 472, 473, 474, -1, -1, 477, - -1, -1, 480, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 498, 499, 500, 3, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, + 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 43, 44, -1, 46, 47, 48, + -1, 50, 51, 52, 53, 54, -1, 56, 57, -1, + 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, + 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, + 79, -1, -1, -1, 83, 84, 85, 86, 87, 88, + -1, 90, 91, 92, -1, 94, 95, 96, 97, 98, + 99, -1, -1, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, + -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, + 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, + -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, + 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, -1, 161, -1, 163, 164, 165, 166, -1, 168, + -1, 170, -1, -1, -1, 174, 175, 176, -1, 178, + -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, + 189, 190, 191, 192, 193, -1, 195, 196, 197, 198, + -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, + -1, 210, 211, 212, 213, 214, 215, 216, 217, -1, + 219, -1, 221, -1, -1, 224, -1, 226, 227, 228, + 229, 230, 231, -1, -1, 234, -1, 236, -1, -1, + 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + -1, 270, 271, 272, 273, 274, -1, 276, 277, -1, + 279, -1, 281, 282, 283, 284, 285, 286, -1, 288, + 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, + 299, -1, 301, -1, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, + 319, 320, 321, -1, 323, 324, 325, 326, 327, 328, + -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, + 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, + 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 360, -1, 362, 363, -1, 365, 366, 367, 368, + 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, + 379, 380, 381, -1, -1, 384, 385, 386, 387, 388, + 389, 390, 391, 392, -1, -1, 395, 396, 397, 398, + -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, + 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, + -1, 420, -1, 422, 423, 424, 425, 426, -1, 428, + 429, 430, -1, -1, 433, 434, 435, 436, 437, -1, + 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, + 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, + 459, 460, 461, 462, 463, 464, -1, 466, -1, 468, + 469, 470, 471, 472, 473, 474, -1, -1, 477, -1, + -1, 480, 481, 482, 483, 484, 485, 486, 487, 488, + 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, + 499, 500, 3, -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, 159, - -1, 161, -1, 163, 164, 165, 166, -1, 168, -1, - 170, -1, -1, -1, 174, 175, 176, -1, 178, -1, - 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, - 190, 191, 192, 193, -1, 195, 196, 197, 198, -1, - 200, 201, 202, 203, 204, 205, 206, -1, 208, -1, - 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, - -1, 221, -1, -1, 224, -1, 226, 227, 228, 229, - 230, 231, -1, -1, 234, -1, 236, -1, -1, 239, - 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, -1, - 270, 271, 272, 273, 274, -1, 276, 277, -1, 279, - -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, - -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, - -1, 301, -1, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, - 320, 321, -1, 323, 324, 325, 326, 327, 328, -1, - 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, - 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, - 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, -1, 362, 363, -1, 365, 366, 367, 368, 369, - 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, - 380, 381, -1, -1, 384, 385, 386, 387, 388, 389, - 390, 391, 392, -1, -1, 395, 396, 397, 398, -1, - 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, - 410, 411, 412, 413, 414, -1, -1, 417, 418, -1, - 420, -1, 422, 423, 424, 425, 426, -1, 428, 429, - 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, - 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, - 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, - 460, 461, 462, 463, 464, -1, 466, -1, 468, 469, - 470, 471, 472, 473, 474, -1, -1, 477, -1, -1, - 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, - 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, - 500, 3, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, + 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, + 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, + 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, + 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, + -1, -1, 83, 84, 85, 86, 87, 88, -1, 90, + 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, + -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, + 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, + 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, + 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, -1, + 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, + -1, -1, -1, 174, 175, 176, -1, 178, -1, 180, + -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, + 191, 192, 193, -1, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, -1, 210, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, -1, -1, 224, -1, 226, 227, 228, 229, 230, + 231, -1, -1, 234, -1, 236, -1, -1, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, -1, 270, + 271, 272, 273, 274, -1, 276, 277, -1, 279, -1, + 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, + -1, 292, 293, 294, -1, -1, 297, 298, 299, -1, + 301, -1, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, + 321, -1, 323, 324, 325, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, -1, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, + 391, 392, -1, -1, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, + -1, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, 435, 436, 437, -1, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, 463, 464, -1, 466, -1, 468, 469, 470, + 471, 472, 473, 474, -1, -1, 477, -1, -1, 480, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, + 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, + 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, + 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, + 63, 64, -1, -1, 67, 68, 69, 70, 71, 72, + 73, -1, 75, 76, 77, 78, 79, -1, -1, -1, + 83, 84, 85, 86, 87, 88, -1, 90, 91, 92, + -1, 94, 95, 96, 97, 98, 99, -1, -1, 102, + 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, + 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, + 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, + -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, + -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, + 153, 154, 155, 156, 157, 158, 159, -1, 161, -1, + 163, 164, 165, 166, -1, 168, -1, 170, -1, -1, + -1, 174, 175, 176, -1, 178, -1, 180, -1, 182, + 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, + 193, -1, 195, 196, 197, 198, -1, 200, 201, 202, + 203, 204, 205, 206, -1, 208, -1, 210, 211, 212, + 213, 214, 215, 216, 217, -1, 219, -1, 221, -1, + -1, 224, -1, 226, 227, 228, 229, 230, 231, -1, + -1, 234, -1, 236, -1, -1, 239, 240, 241, 242, + 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, + 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, + 263, 264, 265, 266, 267, 268, -1, 270, 271, 272, + 273, 274, -1, 276, 277, -1, 279, -1, 281, 282, + 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, + 293, 294, -1, -1, 297, 298, 299, -1, 301, -1, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, -1, -1, -1, -1, 319, 320, 321, -1, + 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, + 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, + 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, + 363, -1, 365, 366, 367, 368, 369, 370, 371, 372, + 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, + -1, 384, 385, 386, 387, 388, 389, 390, 391, 392, + -1, -1, 395, 396, 397, 398, -1, 400, 401, 402, + 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, + 413, 414, -1, -1, 417, 418, -1, 420, -1, 422, + 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, + 433, 434, 435, 436, 437, -1, 439, 440, 441, 442, + 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, + 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, + 463, 464, -1, 466, -1, 468, 469, 470, 471, 472, + 473, 474, -1, -1, 477, -1, -1, 480, 481, 482, + 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, + 493, 494, 495, 496, 497, 498, 499, 500, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, - 32, 33, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, - 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, - 62, 63, 64, -1, -1, 67, 68, 69, 70, 71, - 72, 73, -1, 75, 76, 77, 78, 79, -1, -1, - -1, 83, 84, 85, 86, 87, 88, -1, 90, 91, - 92, -1, 94, 95, 96, 97, 98, 99, -1, -1, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, - 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, - -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, - 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, -1, 161, - -1, 163, 164, 165, 166, -1, 168, -1, 170, -1, - -1, -1, 174, 175, 176, -1, 178, -1, 180, -1, - 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, - 192, 193, -1, 195, 196, 197, 198, -1, 200, 201, - 202, 203, 204, 205, 206, -1, 208, -1, 210, 211, - 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, - -1, -1, 224, -1, 226, 227, 228, 229, 230, 231, - -1, -1, 234, -1, 236, -1, -1, 239, 240, 241, - 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, - 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, - 262, 263, 264, 265, 266, 267, 268, -1, 270, 271, - 272, 273, 274, -1, 276, 277, -1, 279, -1, 281, - 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, - 292, 293, 294, -1, -1, 297, 298, 299, -1, 301, - -1, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, - -1, 323, 324, 325, 326, 327, 328, -1, 330, 331, - 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, - 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, - 362, 363, -1, 365, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, - 392, -1, -1, 395, 396, 397, 398, -1, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, -1, -1, 417, 418, -1, 420, -1, - 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, - -1, 433, 434, 435, 436, 437, -1, 439, 440, 441, - 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, - -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, - 462, 463, 464, -1, 466, -1, 468, 469, 470, 471, - 472, 473, 474, -1, -1, 477, -1, -1, 480, 481, - 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 498, 499, 500, 3, + -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, + 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, + -1, -1, -1, -1, -1, 40, -1, -1, 43, 44, + -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, + -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, + -1, -1, 67, 68, 69, 70, 71, 72, 73, -1, + 75, 76, 77, 78, 79, -1, -1, -1, 83, 84, + 85, 86, 87, 88, -1, 90, 91, 92, -1, 94, + 95, 96, 97, 98, 99, -1, -1, 102, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, + 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, + 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, + 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, + 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, -1, 161, -1, 163, 164, + 165, 166, -1, 168, -1, 170, -1, -1, -1, 174, + 175, 176, -1, 178, -1, 180, -1, 182, 183, 184, + 185, -1, 187, 188, 189, 190, 191, 192, 193, -1, + 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, + 205, 206, -1, 208, -1, 210, 211, 212, 213, 214, + 215, 216, 217, -1, 219, -1, 221, -1, -1, 224, + -1, 226, 227, 228, 229, 230, 231, -1, -1, 234, + -1, 236, -1, -1, 239, 240, 241, 242, 243, 244, + 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, -1, 270, 271, 272, 273, 274, + -1, 276, 277, -1, 279, -1, 281, 282, 283, 284, + 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, + -1, -1, 297, 298, 299, -1, 301, -1, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + -1, -1, -1, -1, 319, 320, 321, -1, 323, 324, + 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, + 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, + 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, -1, 362, 363, -1, + 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, + 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, + 385, 386, 387, 388, -1, 390, 391, 392, -1, -1, + 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + -1, -1, 417, 418, -1, 420, -1, 422, 423, 424, + 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, + 435, 436, 437, -1, 439, 440, 441, 442, 443, 444, + 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, + 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, + -1, 466, -1, 468, 469, 470, 471, 472, 473, 474, + -1, -1, 477, -1, -1, 480, 481, 482, 483, 484, + 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, + 495, 496, 497, 498, 499, 500, 3, -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, 159, -1, 161, -1, 163, - 164, 165, 166, -1, 168, -1, 170, -1, -1, -1, - 174, 175, 176, -1, 178, -1, 180, -1, 182, 183, - 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, - -1, 195, 196, 197, 198, -1, 200, 201, 202, 203, - 204, 205, 206, -1, 208, -1, 210, 211, 212, 213, - 214, 215, 216, 217, -1, 219, -1, 221, -1, -1, - 224, -1, 226, 227, 228, 229, 230, 231, -1, -1, - 234, -1, 236, -1, -1, 239, 240, 241, 242, 243, - 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, - 264, 265, 266, 267, 268, -1, 270, 271, 272, 273, - 274, -1, 276, 277, -1, 279, -1, 281, 282, 283, - 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, - 294, -1, -1, 297, 298, 299, -1, 301, -1, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, -1, -1, -1, -1, 319, 320, 321, -1, 323, - 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, - 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, - 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, - -1, 365, 366, 367, 368, 369, 370, 371, 372, 373, - 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, - 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, - -1, 395, 396, 397, 398, -1, 400, 401, 402, 403, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, -1, -1, 417, 418, -1, 420, -1, 422, 423, - 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, - 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, - 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, - 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, - 464, -1, 466, -1, 468, 469, 470, 471, 472, 473, - 474, -1, -1, 477, -1, -1, 480, 481, 482, 483, - 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, - 494, 495, 496, 497, 498, 499, 500, 3, -1, -1, + -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, + 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, + 47, 48, -1, 50, 51, 52, 53, 54, -1, 56, + 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, + 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, + 77, 78, 79, -1, -1, -1, 83, 84, 85, 86, + 87, 88, -1, 90, 91, 92, -1, 94, 95, 96, + 97, 98, 99, -1, -1, 102, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, + -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, + -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, + 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, + -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, + 157, 158, 159, -1, 161, -1, 163, 164, 165, 166, + -1, 168, -1, 170, -1, -1, -1, 174, 175, 176, + -1, 178, -1, 180, -1, 182, 183, 184, 185, -1, + 187, 188, 189, 190, 191, 192, 193, -1, 195, 196, + 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, + -1, 208, -1, 210, 211, 212, 213, 214, 215, 216, + 217, -1, 219, -1, 221, -1, -1, 224, -1, 226, + 227, 228, 229, 230, 231, -1, -1, 234, -1, 236, + -1, -1, 239, 240, 241, 242, 243, 244, 245, 246, + 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, + 267, 268, -1, 270, 271, 272, 273, 274, -1, 276, + 277, -1, 279, -1, 281, 282, 283, 284, 285, 286, + -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, + 297, 298, 299, -1, 301, -1, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, + -1, -1, 319, 320, 321, -1, 323, 324, 325, 326, + 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, + 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, + -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 360, -1, 362, 363, -1, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, + 387, 388, 389, 390, 391, 392, -1, -1, 395, 396, + 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, + 417, 418, -1, 420, -1, 422, 423, 424, 425, 426, + -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, + 437, -1, 439, 440, 441, 442, 443, 444, 445, 446, + -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, + -1, 458, 459, 460, 461, 462, 463, 464, -1, 466, + -1, 468, 469, 470, 471, 472, 473, 474, -1, -1, + 477, -1, -1, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 498, 499, 500, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, - 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, - -1, 37, -1, -1, -1, -1, 42, 43, 44, -1, - 46, 47, 48, 49, 50, 51, 52, -1, 54, 55, - 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, - -1, 67, 68, 69, 70, 71, 72, 73, -1, 75, - 76, 77, 78, -1, -1, 81, -1, 83, 84, 85, - 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, - 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, - 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, - 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, - -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, - 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, - 146, -1, 148, 149, 150, 151, -1, 153, 154, 155, - 156, 157, 158, -1, -1, 161, -1, 163, 164, 165, - 166, -1, 168, -1, 170, 171, -1, 173, 174, 175, - -1, 177, 178, -1, 180, -1, -1, -1, 184, 185, - -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, - 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, - 206, -1, 208, 209, -1, 211, 212, 213, 214, 215, - 216, 217, -1, 219, -1, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, 231, -1, -1, 234, 235, - 236, 237, -1, 239, 240, 241, 242, 243, 244, 245, - 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, - 266, 267, 268, 269, 270, 271, 272, 273, -1, -1, - 276, 277, 278, 279, -1, -1, 282, 283, 284, 285, - 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, - -1, 297, 298, -1, 300, 301, 302, -1, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, - -1, -1, -1, 319, 320, -1, 322, 323, 324, -1, - 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, - -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, - 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, - 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, - 376, 377, 378, 379, 380, 381, -1, 383, 384, 385, - 386, 387, 388, 389, 390, 391, 392, -1, 394, 395, - 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, -1, -1, - -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, - 426, -1, 428, 429, 430, -1, -1, 433, 434, -1, - 436, -1, -1, 439, 440, 441, 442, 443, 444, 445, - 446, 447, -1, 449, 450, 451, -1, 453, 454, 455, - 456, -1, 458, 459, 460, 461, 462, -1, 464, -1, - 466, 467, 468, 469, 470, 471, 472, 473, 474, -1, - -1, 477, -1, -1, 480, 481, 482, 483, 484, 485, + -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, + 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 43, 44, -1, 46, 47, 48, + -1, 50, 51, 52, 53, 54, -1, 56, 57, -1, + 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, + 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, + 79, -1, -1, -1, 83, 84, 85, 86, 87, 88, + -1, 90, 91, 92, -1, 94, 95, 96, 97, 98, + 99, -1, -1, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, + -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, + 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, + -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, + 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, -1, 161, -1, 163, 164, 165, 166, -1, 168, + -1, 170, -1, -1, -1, 174, 175, 176, -1, 178, + -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, + 189, 190, 191, 192, 193, -1, 195, 196, 197, 198, + -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, + -1, 210, 211, 212, 213, 214, 215, 216, 217, -1, + 219, -1, 221, -1, -1, 224, -1, 226, 227, 228, + 229, 230, 231, -1, -1, 234, -1, 236, -1, -1, + 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + -1, 270, 271, 272, 273, 274, -1, 276, 277, -1, + 279, -1, 281, 282, 283, 284, 285, 286, -1, 288, + 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, + 299, -1, 301, -1, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, + 319, 320, 321, -1, 323, 324, 325, 326, 327, 328, + -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, + 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, + 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 360, -1, 362, 363, -1, 365, 366, 367, 368, + 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, + 379, 380, 381, -1, -1, 384, 385, 386, 387, 388, + 389, 390, 391, 392, -1, -1, 395, 396, 397, 398, + -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, + 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, + -1, 420, -1, 422, 423, 424, 425, 426, -1, 428, + 429, 430, -1, -1, 433, 434, 435, 436, 437, -1, + 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, + 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, + 459, 460, 461, 462, 463, 464, -1, 466, -1, 468, + 469, 470, 471, 472, 473, 474, -1, -1, 477, -1, + -1, 480, 481, 482, 483, 484, 485, 486, 487, 488, + 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, + 499, 500, 3, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, + 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, + 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, + 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, + 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, + -1, -1, 83, 84, 85, 86, 87, 88, -1, 90, + 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, + -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, + 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, + 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, + 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, -1, + 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, + -1, -1, -1, 174, 175, 176, -1, 178, -1, 180, + -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, + 191, 192, 193, -1, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, -1, 210, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, -1, -1, 224, -1, 226, 227, 228, 229, 230, + 231, -1, -1, 234, -1, 236, -1, -1, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, -1, 270, + 271, 272, 273, 274, -1, 276, 277, -1, 279, -1, + 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, + -1, 292, 293, 294, -1, -1, 297, 298, 299, -1, + 301, -1, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, + 321, -1, 323, 324, 325, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, -1, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, + 391, 392, -1, -1, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, + -1, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, 435, 436, 437, -1, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, 463, 464, -1, 466, -1, 468, 469, 470, + 471, 472, 473, 474, -1, -1, 477, -1, -1, 480, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 497, 498, 499, 500, -1, -1, -1, -1, 22, + -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, @@ -17561,7 +18736,7 @@ static const yytype_int16 yycheck[] = 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, -1, 153, 154, 155, 156, 157, 158, -1, -1, 161, -1, 163, 164, 165, 166, -1, 168, -1, - 170, 171, -1, 173, 174, 175, 176, 177, 178, -1, + 170, 171, -1, 173, 174, 175, -1, 177, 178, -1, 180, -1, -1, -1, 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, 209, @@ -17580,15 +18755,15 @@ static const yytype_int16 yycheck[] = 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, -1, 362, 363, 364, 365, 366, 367, -1, 369, + 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, 383, 384, 385, 386, 387, 388, 389, - -1, 391, 392, -1, 394, 395, 396, 397, 398, -1, + 390, 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, -1, -1, -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, -1, 436, -1, -1, 439, - 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, + 440, 441, 442, 443, 444, 445, 446, 447, -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, -1, 464, -1, 466, 467, 468, 469, 470, 471, 472, 473, 474, -1, -1, 477, -1, -1, @@ -17596,170 +18771,218 @@ static const yytype_int16 yycheck[] = -1, -1, -1, -1, -1, -1, -1, 497, 498, 499, 500, -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, + 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, 79, -1, -1, -1, 83, 84, 85, 86, - 87, 88, -1, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, -1, 102, 103, 104, 105, 106, + 77, 78, -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, 152, 153, 154, 155, 156, - 157, 158, 159, -1, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, -1, -1, -1, 174, 175, 176, - -1, 178, -1, 180, -1, 182, 183, -1, 185, -1, - 187, 188, 189, 190, 191, 192, 193, -1, 195, 196, + -1, 148, 149, 150, 151, -1, 153, 154, 155, 156, + 157, 158, -1, -1, 161, -1, 163, 164, 165, 166, + -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, + 177, 178, -1, 180, -1, -1, -1, 184, 185, -1, + 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, -1, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, -1, -1, 224, -1, 226, - 227, 228, 229, 230, 231, -1, -1, 234, -1, 236, - -1, -1, 239, 240, 241, 242, 243, 244, 245, 246, + -1, 208, 209, -1, 211, 212, 213, 214, 215, 216, + 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, + 237, -1, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, -1, 270, 271, 272, 273, 274, -1, 276, - 277, -1, 279, -1, 281, 282, 283, 284, 285, 286, + 267, 268, 269, 270, 271, 272, 273, -1, -1, 276, + 277, 278, 279, -1, -1, 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, -1, 301, -1, 303, 304, 305, 306, - 307, 308, 309, -1, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, -1, 323, 324, 325, 326, + 297, 298, -1, 300, 301, 302, -1, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, + -1, -1, 319, 320, -1, 322, 323, 324, -1, 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, -1, 341, 342, 343, 344, 345, 346, + 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, -1, 365, 366, - 367, 368, -1, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, -1, 395, 396, + 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, + 367, -1, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, 379, 380, 381, -1, 383, 384, 385, 386, + 387, 388, 389, -1, 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, -1, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, -1, 439, 440, 441, 442, 443, 444, 445, 446, + 407, 408, 409, 410, 411, 412, 413, -1, -1, -1, + 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, + -1, 428, 429, 430, -1, -1, 433, 434, -1, 436, + -1, -1, 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, -1, 466, - -1, 468, 469, 470, 471, 472, 473, 474, -1, -1, - 477, -1, -1, 480, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 3, -1, -1, -1, -1, -1, + -1, 458, 459, 460, 461, 462, -1, 464, -1, 466, + 467, 468, 469, 470, 471, 472, 473, 474, -1, -1, + 477, -1, -1, 480, 481, 482, 483, 484, 485, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, - 29, -1, 31, 32, 33, -1, -1, -1, 37, -1, - -1, -1, -1, 42, 43, 44, -1, 46, 47, 48, - 49, 50, 51, 52, -1, 54, 55, 56, 57, -1, - 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, - 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, - -1, -1, 81, -1, 83, 84, 85, 86, 87, 88, - 89, 90, 91, 92, -1, 94, 95, 96, 97, 98, - 99, -1, 101, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, - -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, - 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, - -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, - 149, 150, 151, -1, 153, 154, 155, 156, 157, 158, - -1, -1, 161, -1, 163, 164, 165, 166, -1, 168, - -1, 170, 171, -1, 173, 174, 175, -1, 177, 178, - -1, 180, -1, -1, -1, 184, 185, -1, 187, 188, - 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, - -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, - 209, -1, 211, 212, 213, 214, 215, 216, 217, -1, - 219, -1, 221, 222, 223, 224, 225, 226, 227, 228, - 229, 230, 231, -1, -1, 234, 235, 236, 237, -1, - 239, 240, 241, 242, 243, 244, 245, 246, -1, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, -1, -1, 276, 277, 278, - 279, -1, -1, 282, 283, 284, 285, 286, -1, 288, - 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, - -1, 300, 301, 302, -1, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, - 319, 320, -1, 322, 323, 324, -1, 326, 327, 328, - -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, - 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, -1, 362, 363, 364, 365, 366, 367, -1, - 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, - 379, 380, 381, -1, 383, 384, 385, 386, 387, 388, - 389, -1, 391, 392, -1, 394, 395, 396, 397, 398, - -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, -1, 413, -1, -1, -1, 417, 418, - -1, 420, 421, 422, 423, 424, 425, 426, -1, 428, - 429, 430, -1, -1, 433, 434, -1, 436, -1, -1, - 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, - 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, - 459, 460, 461, 462, -1, 464, -1, 466, 467, 468, - 469, 470, 471, 472, 473, 474, -1, 22, 477, -1, - -1, 480, 481, 482, 483, 484, 485, 32, -1, 34, - 35, -1, -1, -1, -1, 22, -1, -1, 497, 498, - 499, 500, -1, -1, -1, 32, -1, 52, -1, -1, - -1, -1, -1, -1, -1, -1, 61, -1, -1, -1, - -1, -1, -1, -1, -1, 52, -1, -1, -1, -1, - 75, -1, -1, -1, 61, -1, -1, -1, -1, -1, - -1, 86, -1, -1, -1, -1, -1, -1, 75, -1, - -1, -1, -1, 98, -1, 100, -1, -1, -1, 86, - -1, -1, -1, -1, -1, -1, 111, -1, -1, -1, - -1, 98, -1, 100, -1, -1, -1, -1, -1, -1, - -1, 126, 127, -1, 111, -1, -1, -1, -1, -1, - -1, -1, 137, -1, -1, -1, -1, -1, 143, 126, - 127, -1, -1, -1, -1, -1, 151, -1, -1, -1, - 137, -1, -1, -1, -1, -1, 143, -1, -1, -1, - -1, -1, -1, 168, 151, -1, -1, 172, -1, -1, + 497, 498, 499, 500, -1, -1, -1, -1, 22, 23, + 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, + 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, + 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, + 64, -1, -1, 67, 68, 69, 70, 71, 72, 73, + -1, 75, 76, 77, 78, 79, -1, -1, -1, 83, + 84, 85, 86, 87, 88, -1, 90, 91, 92, -1, + 94, 95, 96, 97, 98, 99, -1, -1, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, + 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, + 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, + 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, -1, 161, -1, 163, + 164, 165, 166, -1, 168, -1, 170, -1, -1, -1, + 174, 175, 176, -1, 178, -1, 180, -1, 182, 183, + -1, 185, -1, 187, 188, 189, 190, 191, 192, 193, + -1, 195, 196, 197, 198, -1, 200, 201, 202, 203, + 204, 205, 206, -1, 208, -1, 210, 211, 212, 213, + 214, 215, 216, 217, -1, 219, -1, 221, -1, -1, + 224, -1, 226, 227, 228, 229, 230, 231, -1, -1, + 234, -1, 236, -1, -1, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, -1, 270, 271, 272, 273, + 274, -1, 276, 277, -1, 279, -1, 281, 282, 283, + 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, + 294, -1, -1, 297, 298, 299, -1, 301, -1, 303, + 304, 305, 306, 307, 308, 309, -1, 311, 312, 313, + 314, -1, -1, -1, -1, 319, 320, 321, -1, 323, + 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, + 334, 335, -1, 337, 338, 339, -1, 341, 342, 343, + 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, + -1, 365, 366, 367, 368, -1, 370, 371, 372, 373, + 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, + 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, + -1, 395, 396, 397, 398, -1, 400, 401, 402, 403, + 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, + 414, -1, -1, 417, 418, -1, 420, -1, 422, 423, + 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, + 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, + 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, + 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, + 464, -1, 466, -1, 468, 469, 470, 471, 472, 473, + 474, -1, -1, 477, -1, -1, 480, 481, 482, 483, + 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 499, 500, 3, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, + -1, 37, -1, -1, -1, -1, 42, 43, 44, -1, + 46, 47, 48, 49, 50, 51, 52, -1, 54, 55, + 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, + -1, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, -1, -1, 81, -1, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, + -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, + 146, -1, 148, 149, 150, 151, -1, 153, 154, 155, + 156, 157, 158, -1, -1, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, 171, -1, 173, 174, 175, + -1, 177, 178, -1, 180, -1, -1, -1, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, 209, -1, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, -1, -1, 234, 235, + 236, 237, -1, 239, 240, 241, 242, 243, 244, 245, + 246, -1, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, -1, -1, + 276, 277, 278, 279, -1, -1, 282, 283, 284, 285, + 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, + -1, 297, 298, -1, 300, 301, 302, -1, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, -1, 322, 323, 324, -1, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, + 366, 367, -1, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, -1, 383, 384, 385, + 386, 387, 388, 389, -1, 391, 392, -1, 394, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, -1, 413, -1, -1, + -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, -1, + 436, -1, -1, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, -1, 464, -1, + 466, 467, 468, 469, 470, 471, 472, 473, 474, -1, + 22, 477, -1, -1, 480, 481, 482, 483, 484, 485, + 32, -1, 34, 35, -1, -1, -1, -1, 22, -1, + -1, 497, 498, 499, 500, -1, -1, -1, 32, -1, + 52, -1, -1, -1, -1, -1, -1, -1, -1, 61, + -1, -1, -1, -1, -1, -1, -1, -1, 52, -1, + -1, -1, -1, 75, -1, -1, -1, 61, -1, -1, + -1, -1, -1, -1, 86, -1, -1, -1, -1, -1, + -1, 75, -1, -1, -1, -1, 98, -1, 100, -1, + -1, -1, 86, -1, -1, -1, -1, -1, -1, 111, + -1, -1, -1, -1, 98, -1, 100, -1, -1, -1, + -1, -1, -1, -1, 126, 127, -1, 111, -1, -1, + -1, -1, -1, -1, -1, 137, -1, -1, -1, -1, + -1, 143, 126, 127, -1, -1, -1, -1, -1, 151, + -1, -1, -1, 137, -1, -1, -1, -1, -1, 143, + -1, -1, -1, -1, -1, -1, 168, 151, -1, -1, + 172, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 168, -1, -1, -1, 172, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 168, -1, -1, -1, 172, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 214, + -1, -1, 214, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 214, -1, -1, - -1, -1, -1, -1, -1, 240, -1, -1, -1, -1, + 214, -1, -1, -1, -1, -1, -1, -1, 240, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 240, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 240, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 315, 316, 317, -1, -1, -1, -1, -1, 323, -1, - -1, 326, -1, -1, -1, -1, -1, -1, 315, 316, - 317, -1, -1, -1, -1, -1, 323, -1, -1, 326, + -1, -1, -1, 315, 316, 317, -1, -1, -1, -1, + -1, 323, -1, -1, 326, -1, -1, -1, -1, -1, + -1, 315, 316, 317, -1, -1, -1, -1, -1, 323, + -1, -1, 326, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 357, -1, -1, -1, -1, + -1, -1, -1, -1, 366, -1, -1, -1, -1, -1, + -1, -1, -1, 357, -1, -1, -1, -1, -1, -1, + 382, -1, 366, -1, -1, -1, -1, 389, -1, -1, + -1, 393, -1, -1, -1, -1, -1, -1, 382, -1, + -1, 403, -1, -1, -1, 389, -1, -1, -1, 393, + -1, -1, -1, 415, -1, -1, -1, 419, -1, 403, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 357, -1, -1, -1, -1, -1, -1, -1, - -1, 366, -1, -1, -1, -1, -1, -1, -1, -1, - 357, -1, -1, -1, -1, -1, -1, 382, -1, 366, - -1, -1, -1, -1, 389, -1, -1, -1, 393, -1, - -1, -1, -1, -1, -1, 382, -1, -1, 403, -1, - -1, -1, 389, -1, -1, -1, 393, -1, -1, -1, - 415, -1, -1, -1, 419, -1, 403, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 415, -1, - -1, -1, 419, -1, 439, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 452, -1, -1, - -1, -1, 439, 458, -1, -1, -1, -1, 463, -1, - -1, -1, 467, -1, -1, 452, -1, -1, -1, -1, - -1, 458, -1, -1, 479, -1, 463, -1, -1, -1, + -1, 415, -1, -1, -1, 419, -1, 439, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 479, -1, -1, -1, -1, -1, 503, -1, + 452, -1, -1, -1, -1, 439, 458, -1, -1, -1, + -1, 463, -1, -1, -1, 467, -1, -1, 452, -1, + -1, -1, -1, -1, 458, -1, -1, 479, -1, 463, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 517, -1, -1, -1, 503, -1, -1, -1, + -1, -1, -1, -1, -1, 479, -1, -1, -1, -1, + -1, 503, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 517, -1, -1, -1, 503, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 517 + -1, -1, -1, 517 }; -/* 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, 168, 172, 198, 240, 315, 316, 317, 323, 326, 357, 366, 382, 389, 393, 403, 415, 419, 439, 452, 455, 458, 463, 479, 503, 517, 529, 530, 531, - 532, 533, 540, 551, 552, 553, 556, 557, 559, 570, - 588, 636, 646, 649, 652, 656, 658, 661, 662, 666, - 672, 674, 678, 685, 689, 690, 691, 698, 703, 719, - 720, 723, 724, 727, 729, 730, 731, 732, 734, 736, - 737, 741, 794, 795, 964, 966, 967, 968, 969, 974, - 977, 983, 984, 985, 989, 433, 482, 965, 203, 373, - 384, 419, 469, 108, 192, 554, 965, 3, 22, 23, + 532, 543, 552, 554, 559, 575, 578, 579, 581, 585, + 586, 590, 597, 599, 602, 603, 651, 657, 660, 661, + 679, 680, 681, 682, 684, 686, 687, 691, 744, 745, + 914, 917, 920, 927, 928, 930, 933, 934, 935, 942, + 946, 952, 953, 956, 961, 965, 966, 967, 970, 973, + 974, 975, 979, 980, 982, 433, 482, 600, 203, 373, + 384, 419, 469, 108, 192, 968, 600, 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, @@ -17800,10 +19023,10 @@ static const yytype_int16 yystos[] = 467, 468, 469, 470, 471, 472, 473, 474, 477, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, - 563, 639, 640, 641, 873, 953, 957, 3, 176, 247, - 412, 558, 563, 639, 290, 965, 55, 172, 517, 583, + 545, 823, 903, 907, 985, 986, 987, 3, 176, 247, + 412, 545, 929, 985, 290, 600, 55, 172, 517, 674, 178, 241, 295, 314, 373, 423, 425, 442, 448, 451, - 634, 654, 697, 5, 30, 326, 563, 564, 952, 3, + 583, 649, 926, 5, 30, 326, 545, 546, 902, 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, @@ -17819,912 +19042,472 @@ static const yytype_int16 yystos[] = 414, 415, 416, 419, 421, 427, 429, 430, 431, 432, 435, 437, 438, 441, 447, 448, 452, 457, 463, 464, 465, 467, 475, 476, 478, 479, 486, 487, 488, 489, - 490, 491, 492, 493, 494, 495, 496, 569, 639, 643, - 645, 24, 81, 97, 146, 156, 169, 174, 203, 246, + 490, 491, 492, 493, 494, 495, 496, 551, 985, 989, + 991, 24, 81, 97, 146, 156, 169, 174, 203, 246, 250, 320, 335, 370, 373, 384, 387, 405, 419, 425, - 426, 436, 442, 469, 654, 667, 668, 671, 965, 952, - 100, 137, 467, 517, 532, 533, 540, 556, 557, 570, - 588, 636, 646, 649, 656, 658, 661, 662, 666, 674, - 681, 685, 691, 698, 719, 723, 724, 727, 729, 964, - 966, 967, 969, 974, 977, 983, 989, 108, 75, 66, + 426, 436, 442, 469, 583, 652, 653, 656, 600, 902, + 100, 137, 467, 517, 532, 543, 552, 554, 575, 578, + 579, 585, 586, 590, 599, 603, 651, 657, 660, 661, + 679, 914, 917, 920, 927, 928, 938, 942, 946, 952, + 956, 961, 970, 973, 979, 980, 982, 108, 75, 66, 79, 81, 159, 232, 281, 291, 303, 321, 369, 414, - 435, 437, 441, 463, 517, 562, 563, 564, 730, 795, - 797, 799, 809, 816, 817, 873, 875, 876, 108, 5, - 563, 565, 721, 563, 952, 30, 178, 241, 388, 429, - 433, 563, 975, 976, 987, 965, 30, 132, 750, 751, - 178, 241, 373, 388, 429, 978, 979, 987, 965, 563, - 729, 741, 988, 563, 816, 419, 747, 562, 173, 517, - 971, 517, 345, 742, 743, 952, 742, 730, 731, 983, - 0, 520, 467, 679, 122, 213, 454, 214, 147, 218, - 296, 447, 753, 754, 799, 799, 730, 732, 734, 521, - 30, 429, 433, 729, 988, 192, 562, 952, 192, 562, - 192, 816, 192, 562, 275, 565, 515, 519, 566, 567, - 517, 82, 108, 174, 203, 246, 373, 384, 419, 442, - 469, 561, 108, 729, 562, 423, 425, 423, 425, 355, - 192, 562, 562, 174, 246, 345, 384, 419, 469, 647, - 380, 203, 30, 952, 192, 569, 252, 436, 107, 419, - 419, 469, 377, 380, 192, 563, 669, 959, 192, 949, - 952, 192, 952, 517, 677, 295, 425, 681, 3, 463, - 639, 643, 682, 684, 685, 687, 688, 679, 563, 565, - 558, 517, 517, 167, 517, 730, 817, 517, 517, 562, - 517, 517, 172, 517, 517, 517, 517, 730, 795, 799, - 809, 510, 566, 40, 563, 810, 811, 810, 382, 521, - 733, 37, 42, 101, 173, 209, 225, 235, 269, 315, - 322, 364, 383, 452, 813, 811, 40, 563, 810, 812, - 503, 821, 565, 506, 517, 517, 725, 976, 976, 976, - 500, 224, 519, 290, 4, 6, 7, 8, 9, 10, - 39, 54, 56, 57, 65, 71, 72, 83, 112, 115, - 117, 136, 152, 160, 165, 182, 183, 216, 217, 219, - 247, 268, 270, 275, 280, 283, 292, 342, 368, 397, - 429, 430, 438, 464, 501, 508, 509, 510, 515, 517, - 522, 523, 525, 526, 563, 565, 730, 784, 833, 836, - 839, 840, 841, 843, 844, 845, 846, 848, 849, 865, - 867, 868, 869, 870, 871, 872, 873, 874, 876, 877, - 892, 893, 904, 926, 931, 939, 940, 941, 953, 954, - 955, 938, 940, 978, 978, 565, 978, 500, 172, 431, - 506, 519, 566, 663, 816, 3, 171, 173, 467, 685, - 970, 972, 171, 973, 865, 910, 911, 742, 521, 517, - 961, 518, 518, 518, 531, 562, 172, 295, 706, 157, - 663, 721, 30, 132, 748, 748, 59, 748, 162, 167, - 238, 287, 759, 761, 762, 787, 789, 790, 791, 181, - 290, 457, 290, 753, 754, 517, 420, 986, 500, 224, - 152, 26, 32, 137, 294, 353, 357, 389, 460, 545, - 548, 549, 353, 152, 40, 60, 106, 202, 251, 261, - 273, 305, 353, 359, 384, 389, 403, 534, 537, 548, - 152, 353, 389, 548, 152, 353, 389, 548, 152, 40, - 555, 865, 932, 568, 569, 567, 3, 30, 37, 42, - 49, 55, 81, 83, 89, 101, 132, 171, 173, 176, - 177, 194, 209, 222, 223, 225, 235, 237, 247, 269, - 278, 300, 302, 322, 364, 383, 394, 412, 421, 441, - 465, 467, 518, 639, 644, 865, 913, 914, 956, 962, - 865, 419, 562, 563, 518, 517, 623, 373, 634, 654, - 275, 650, 40, 469, 192, 562, 192, 562, 638, 192, - 562, 192, 562, 192, 563, 653, 89, 694, 152, 483, - 90, 129, 308, 424, 192, 563, 152, 519, 960, 63, - 360, 521, 670, 152, 521, 670, 152, 290, 675, 676, - 865, 962, 355, 518, 521, 4, 160, 290, 438, 508, - 509, 536, 539, 565, 680, 682, 683, 686, 955, 681, - 431, 517, 578, 582, 865, 911, 517, 3, 68, 69, - 109, 110, 113, 114, 189, 190, 253, 254, 255, 256, - 257, 258, 259, 260, 263, 264, 337, 338, 378, 379, - 473, 474, 497, 498, 565, 851, 852, 853, 854, 855, - 856, 857, 858, 859, 860, 861, 862, 863, 916, 917, - 811, 812, 865, 562, 865, 918, 508, 509, 563, 866, - 867, 893, 904, 920, 517, 865, 910, 921, 865, 58, - 172, 233, 432, 865, 911, 924, 865, 518, 564, 517, - 421, 767, 768, 768, 750, 751, 799, 220, 745, 37, - 225, 383, 813, 225, 300, 814, 799, 814, 225, 813, - 517, 225, 814, 148, 200, 801, 225, 768, 517, 564, - 517, 768, 297, 865, 980, 982, 913, 3, 37, 42, - 49, 54, 55, 56, 57, 71, 72, 81, 83, 89, - 101, 112, 115, 165, 171, 173, 177, 194, 209, 216, - 217, 219, 222, 223, 225, 235, 237, 247, 268, 269, - 270, 278, 283, 300, 302, 322, 342, 364, 368, 383, - 390, 394, 397, 412, 421, 429, 430, 441, 447, 464, - 467, 639, 642, 827, 829, 830, 832, 834, 836, 838, - 840, 841, 842, 844, 845, 848, 849, 915, 958, 40, - 236, 563, 517, 515, 730, 466, 847, 865, 930, 847, - 847, 517, 517, 835, 835, 325, 730, 517, 837, 523, - 71, 72, 847, 865, 835, 517, 517, 481, 503, 517, - 850, 517, 850, 865, 865, 865, 148, 942, 943, 865, - 911, 912, 730, 865, 910, 564, 894, 895, 896, 9, - 569, 519, 566, 933, 566, 517, 565, 517, 517, 565, - 955, 3, 8, 11, 15, 16, 17, 18, 19, 20, - 21, 36, 40, 46, 53, 80, 177, 194, 199, 222, - 223, 237, 275, 278, 292, 295, 394, 501, 504, 505, - 506, 508, 509, 510, 511, 512, 513, 902, 903, 904, - 906, 936, 480, 878, 302, 865, 521, 745, 517, 565, - 745, 3, 117, 241, 536, 565, 849, 981, 104, 982, - 982, 563, 40, 563, 518, 521, 679, 521, 518, 743, - 949, 950, 40, 961, 663, 193, 355, 220, 623, 389, - 172, 468, 722, 732, 732, 30, 755, 756, 865, 59, - 732, 749, 164, 272, 775, 227, 273, 341, 392, 454, - 4, 9, 30, 770, 865, 508, 509, 771, 772, 865, - 867, 787, 788, 762, 761, 759, 760, 167, 790, 285, - 792, 59, 738, 739, 740, 802, 866, 940, 940, 759, - 787, 911, 236, 562, 74, 82, 93, 169, 192, 329, - 448, 563, 605, 615, 630, 82, 93, 728, 93, 728, - 517, 431, 517, 603, 245, 451, 603, 93, 521, 431, - 562, 3, 832, 536, 59, 538, 536, 536, 106, 251, - 261, 59, 431, 479, 503, 535, 266, 373, 535, 537, - 816, 93, 431, 728, 373, 562, 431, 373, 554, 563, - 578, 516, 527, 913, 913, 914, 521, 753, 754, 13, - 14, 222, 222, 431, 431, 563, 622, 627, 479, 581, - 562, 345, 384, 419, 469, 647, 380, 152, 100, 588, - 651, 656, 691, 989, 144, 829, 562, 275, 534, 657, - 275, 517, 623, 40, 275, 623, 275, 517, 648, 275, - 199, 655, 192, 563, 617, 695, 569, 152, 172, 673, - 669, 568, 519, 959, 949, 952, 952, 959, 518, 521, - 13, 681, 687, 4, 955, 4, 955, 565, 569, 580, - 587, 55, 102, 123, 141, 145, 168, 171, 187, 280, - 288, 310, 339, 584, 40, 518, 865, 518, 172, 521, - 518, 318, 919, 518, 866, 866, 11, 15, 16, 19, - 20, 21, 199, 222, 292, 504, 505, 506, 508, 509, - 510, 511, 512, 513, 904, 866, 518, 818, 819, 875, - 167, 172, 922, 923, 521, 518, 40, 924, 911, 924, - 924, 172, 518, 40, 810, 517, 950, 4, 9, 563, - 763, 765, 766, 940, 938, 178, 241, 419, 423, 425, - 451, 562, 746, 476, 822, 799, 225, 799, 290, 457, - 815, 799, 225, 940, 799, 282, 282, 517, 799, 564, - 823, 824, 517, 564, 823, 521, 518, 521, 519, 517, - 832, 517, 517, 519, 39, 831, 517, 851, 852, 853, - 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, - 864, 518, 521, 835, 570, 662, 698, 703, 726, 729, - 966, 983, 911, 912, 517, 475, 927, 928, 865, 912, - 955, 865, 897, 898, 899, 900, 847, 847, 8, 15, - 16, 19, 20, 21, 504, 505, 506, 508, 509, 510, - 511, 512, 513, 563, 902, 907, 518, 911, 429, 429, - 955, 955, 517, 563, 355, 947, 167, 516, 518, 521, - 527, 521, 524, 510, 567, 911, 955, 865, 864, 864, - 829, 865, 865, 865, 865, 865, 865, 865, 865, 5, - 569, 963, 429, 45, 416, 937, 959, 865, 865, 517, - 730, 925, 132, 160, 275, 280, 285, 438, 449, 865, - 280, 517, 865, 431, 53, 177, 194, 199, 237, 394, - 865, 865, 865, 865, 865, 865, 865, 865, 865, 865, - 30, 38, 399, 901, 515, 519, 935, 181, 163, 879, - 368, 517, 893, 941, 172, 796, 913, 796, 517, 565, - 563, 562, 970, 551, 562, 865, 521, 518, 250, 275, - 744, 457, 665, 562, 700, 517, 563, 705, 715, 716, - 718, 563, 565, 563, 565, 41, 126, 757, 521, 457, - 757, 266, 732, 368, 369, 508, 509, 772, 774, 867, - 392, 227, 291, 313, 313, 521, 512, 4, 773, 955, - 773, 368, 369, 774, 562, 948, 279, 396, 793, 517, - 950, 951, 521, 181, 457, 199, 181, 220, 788, 760, - 518, 353, 548, 517, 192, 615, 952, 227, 275, 227, - 457, 517, 608, 828, 829, 952, 563, 192, 952, 192, - 563, 26, 137, 389, 544, 547, 569, 599, 613, 952, - 569, 607, 626, 952, 545, 952, 353, 389, 534, 548, - 536, 959, 952, 536, 959, 952, 536, 353, 389, 548, - 952, 952, 952, 952, 353, 389, 548, 952, 952, 565, - 509, 865, 932, 753, 753, 753, 465, 914, 193, 358, - 752, 865, 865, 280, 560, 565, 280, 560, 563, 334, - 577, 518, 521, 288, 172, 431, 572, 650, 469, 562, - 562, 638, 562, 562, 653, 562, 295, 634, 517, 730, - 517, 152, 152, 237, 563, 605, 615, 618, 621, 631, - 633, 479, 481, 610, 151, 729, 152, 479, 696, 152, - 518, 913, 40, 152, 3, 517, 275, 290, 563, 3, - 670, 568, 670, 290, 670, 675, 865, 578, 510, 515, - 517, 536, 579, 686, 871, 872, 518, 521, 40, 576, - 565, 576, 275, 280, 339, 576, 59, 576, 829, 518, - 865, 865, 865, 922, 829, 866, 866, 866, 866, 866, - 866, 132, 275, 285, 866, 866, 866, 866, 866, 866, - 866, 866, 866, 866, 518, 521, 40, 820, 865, 865, - 923, 922, 829, 518, 518, 518, 911, 829, 950, 518, - 313, 512, 313, 369, 512, 517, 517, 745, 423, 425, - 423, 425, 562, 747, 747, 747, 865, 181, 776, 815, - 799, 865, 517, 799, 167, 517, 564, 806, 815, 829, - 518, 521, 823, 518, 980, 3, 915, 39, 831, 563, - 826, 826, 3, 515, 515, 955, 431, 431, 431, 431, - 829, 454, 518, 516, 911, 865, 139, 928, 929, 518, - 518, 518, 527, 521, 524, 519, 518, 518, 500, 500, - 518, 518, 950, 517, 865, 944, 563, 865, 865, 894, - 943, 518, 518, 518, 500, 866, 866, 145, 911, 172, - 132, 160, 280, 285, 438, 449, 517, 145, 907, 865, - 416, 937, 865, 925, 865, 431, 517, 730, 865, 932, - 568, 517, 517, 155, 880, 797, 798, 822, 753, 822, - 955, 864, 961, 961, 250, 517, 798, 476, 664, 40, - 59, 701, 711, 718, 933, 521, 796, 506, 722, 722, - 502, 758, 756, 292, 902, 905, 758, 4, 955, 774, - 291, 454, 771, 521, 244, 950, 738, 59, 940, 517, - 564, 59, 266, 431, 865, 275, 630, 517, 152, 517, - 608, 203, 627, 628, 589, 40, 176, 598, 624, 589, - 26, 137, 357, 359, 389, 541, 542, 543, 549, 550, - 152, 670, 152, 670, 599, 613, 599, 518, 521, 565, - 592, 506, 519, 518, 521, 431, 373, 93, 431, 728, - 373, 431, 431, 431, 373, 555, 527, 516, 527, 752, - 752, 752, 914, 282, 282, 518, 517, 571, 3, 406, - 407, 565, 586, 622, 577, 562, 657, 517, 40, 623, - 648, 655, 650, 355, 419, 565, 659, 660, 627, 562, - 562, 638, 562, 518, 521, 288, 603, 288, 290, 602, - 952, 479, 637, 562, 603, 40, 562, 518, 419, 865, - 653, 587, 152, 562, 673, 959, 574, 585, 686, 580, - 565, 565, 280, 627, 510, 627, 565, 510, 627, 565, - 518, 518, 923, 172, 132, 285, 517, 821, 818, 517, - 518, 518, 518, 563, 763, 822, 747, 747, 747, 747, - 562, 562, 562, 59, 186, 785, 815, 950, 517, 803, - 804, 805, 868, 870, 950, 167, 80, 825, 824, 518, - 518, 515, 829, 518, 521, 518, 955, 516, 955, 518, - 852, 854, 855, 856, 855, 856, 856, 518, 427, 865, - 143, 865, 897, 907, 850, 850, 518, 865, 944, 945, - 946, 40, 199, 518, 947, 864, 865, 36, 36, 865, - 518, 865, 172, 517, 915, 865, 518, 145, 866, 866, - 145, 145, 865, 865, 516, 527, 517, 934, 754, 476, - 865, 301, 884, 521, 776, 752, 776, 518, 726, 865, - 361, 709, 563, 266, 321, 117, 304, 517, 699, 729, - 518, 521, 705, 664, 865, 164, 231, 517, 758, 291, - 562, 518, 951, 181, 730, 731, 940, 951, 952, 952, - 518, 152, 628, 615, 628, 589, 617, 521, 518, 119, - 207, 273, 275, 614, 517, 33, 59, 635, 624, 74, - 80, 93, 117, 119, 207, 275, 280, 329, 347, 448, - 457, 594, 595, 609, 176, 117, 191, 275, 603, 535, - 107, 117, 176, 275, 405, 408, 537, 603, 389, 543, - 442, 952, 563, 547, 3, 37, 42, 49, 55, 81, - 83, 89, 101, 171, 173, 176, 177, 194, 209, 222, - 223, 225, 235, 237, 247, 269, 274, 278, 292, 300, - 302, 322, 364, 383, 390, 394, 412, 421, 441, 447, - 467, 508, 509, 536, 565, 590, 629, 639, 645, 829, - 905, 956, 569, 626, 952, 952, 952, 952, 952, 952, - 952, 952, 952, 952, 578, 932, 932, 518, 518, 518, - 753, 107, 373, 519, 535, 586, 517, 621, 729, 696, - 40, 517, 634, 192, 562, 518, 521, 518, 657, 517, - 40, 612, 610, 618, 86, 677, 107, 273, 623, 729, - 648, 729, 655, 518, 617, 457, 693, 670, 518, 521, - 627, 866, 172, 517, 915, 823, 518, 521, 518, 776, - 562, 562, 562, 562, 30, 103, 182, 367, 517, 777, - 778, 779, 780, 781, 782, 783, 865, 865, 478, 881, - 518, 867, 908, 909, 199, 181, 800, 804, 518, 806, - 807, 808, 959, 831, 955, 831, 563, 831, 516, 516, - 865, 521, 518, 563, 865, 867, 865, 865, 865, 915, - 518, 865, 36, 36, 865, 865, 145, 518, 509, 932, - 518, 913, 518, 865, 518, 517, 563, 885, 785, 518, - 785, 565, 518, 939, 463, 418, 456, 710, 563, 704, - 714, 290, 707, 506, 718, 709, 907, 59, 518, 518, - 462, 463, 735, 589, 615, 518, 518, 479, 620, 120, - 195, 205, 119, 459, 865, 117, 40, 517, 959, 952, - 866, 120, 195, 119, 280, 227, 562, 620, 88, 635, - 192, 280, 536, 865, 635, 280, 508, 509, 539, 563, - 829, 670, 670, 3, 247, 412, 956, 960, 506, 431, - 431, 516, 516, 752, 518, 518, 563, 578, 457, 573, - 575, 627, 518, 637, 40, 419, 865, 587, 419, 275, - 517, 565, 696, 621, 151, 729, 149, 201, 602, 122, - 137, 328, 637, 107, 696, 479, 990, 40, 517, 290, - 563, 692, 517, 585, 866, 915, 518, 518, 9, 354, - 769, 785, 517, 391, 517, 518, 521, 563, 882, 883, - 336, 786, 521, 518, 517, 564, 59, 518, 199, 518, - 807, 516, 829, 944, 516, 192, 518, 865, 865, 865, - 527, 516, 527, 518, 518, 563, 886, 881, 565, 881, - 521, 462, 933, 518, 521, 91, 709, 865, 518, 951, - 951, 347, 620, 517, 611, 589, 518, 191, 517, 865, - 275, 595, 620, 623, 952, 40, 152, 825, 960, 512, - 590, 952, 952, 518, 535, 124, 518, 610, 729, 729, - 518, 562, 152, 40, 518, 952, 637, 30, 85, 94, - 118, 191, 204, 405, 408, 606, 606, 369, 369, 40, - 64, 74, 241, 419, 865, 587, 562, 517, 563, 708, - 717, 875, 518, 518, 517, 881, 911, 517, 911, 779, - 40, 521, 865, 457, 764, 867, 940, 950, 811, 517, - 811, 865, 932, 932, 310, 887, 786, 786, 729, 304, - 729, 704, 290, 517, 702, 562, 589, 569, 616, 619, - 409, 471, 596, 597, 517, 591, 865, 518, 249, 632, - 191, 457, 546, 512, 442, 578, 565, 696, 602, 990, - 517, 562, 729, 610, 677, 729, 74, 293, 74, 729, - 518, 693, 865, 80, 712, 518, 521, 712, 9, 786, - 518, 778, 518, 885, 883, 371, 518, 940, 516, 516, - 516, 59, 753, 764, 764, 710, 93, 717, 133, 623, - 506, 518, 521, 534, 518, 273, 604, 173, 309, 395, - 290, 600, 601, 625, 591, 865, 442, 40, 517, 990, - 602, 637, 990, 293, 293, 517, 518, 959, 713, 959, - 696, 708, 713, 518, 764, 518, 766, 518, 910, 184, - 340, 369, 888, 462, 952, 518, 276, 454, 632, 590, - 619, 518, 597, 205, 122, 454, 290, 625, 290, 600, - 729, 717, 712, 757, 822, 757, 53, 104, 444, 865, - 889, 890, 889, 889, 518, 729, 822, 389, 601, 63, - 273, 360, 389, 593, 593, 990, 518, 713, 758, 758, - 890, 368, 166, 324, 166, 324, 148, 891, 891, 891, - 716, 589, 25, 117, 280, 696, 757, 36, 104, 181, - 273, 428, 822, 822, 758, 890, 368, 298 + 435, 437, 441, 463, 517, 544, 545, 546, 680, 745, + 747, 749, 759, 766, 767, 823, 825, 826, 108, 5, + 545, 547, 954, 545, 902, 30, 178, 241, 388, 429, + 433, 545, 971, 972, 977, 600, 30, 132, 700, 701, + 178, 241, 373, 388, 429, 947, 948, 977, 600, 545, + 679, 691, 978, 545, 766, 419, 697, 544, 173, 517, + 958, 517, 345, 692, 693, 902, 692, 680, 681, 973, + 0, 520, 122, 213, 454, 147, 218, 296, 447, 703, + 704, 749, 749, 680, 682, 684, 521, 467, 936, 214, + 30, 429, 433, 679, 978, 192, 544, 902, 192, 544, + 192, 766, 192, 544, 275, 547, 341, 601, 515, 519, + 548, 549, 517, 82, 108, 174, 203, 246, 373, 384, + 419, 442, 469, 932, 108, 679, 544, 423, 425, 423, + 425, 355, 192, 544, 544, 380, 174, 246, 345, 384, + 419, 469, 658, 203, 30, 902, 192, 551, 252, 436, + 107, 419, 419, 469, 377, 380, 192, 545, 654, 909, + 192, 899, 902, 192, 902, 517, 589, 295, 425, 938, + 3, 463, 939, 941, 942, 944, 945, 985, 989, 936, + 545, 547, 929, 517, 517, 167, 517, 680, 767, 517, + 517, 544, 517, 517, 172, 517, 517, 517, 517, 680, + 745, 749, 759, 510, 548, 40, 545, 760, 761, 760, + 382, 521, 683, 37, 42, 101, 173, 209, 225, 235, + 269, 315, 322, 364, 383, 452, 763, 761, 40, 545, + 760, 762, 503, 771, 547, 506, 517, 517, 915, 972, + 972, 972, 500, 224, 519, 290, 4, 6, 7, 8, + 9, 10, 39, 54, 56, 57, 65, 71, 72, 83, + 112, 115, 117, 136, 152, 160, 165, 182, 183, 216, + 217, 219, 247, 268, 270, 275, 280, 283, 292, 342, + 368, 397, 429, 430, 438, 464, 501, 508, 509, 510, + 515, 517, 522, 523, 525, 526, 545, 547, 680, 734, + 783, 786, 789, 790, 791, 793, 794, 795, 796, 798, + 799, 815, 817, 818, 819, 820, 821, 822, 823, 824, + 826, 827, 842, 843, 854, 876, 881, 889, 890, 891, + 903, 904, 905, 888, 890, 947, 947, 547, 947, 500, + 172, 431, 506, 601, 519, 548, 766, 962, 3, 171, + 173, 467, 942, 957, 959, 171, 960, 815, 860, 861, + 692, 521, 517, 911, 518, 518, 518, 531, 172, 295, + 562, 157, 962, 30, 132, 698, 698, 59, 698, 162, + 167, 238, 287, 709, 711, 712, 737, 739, 740, 741, + 181, 290, 457, 290, 703, 704, 517, 544, 954, 420, + 976, 500, 224, 152, 26, 32, 137, 294, 353, 357, + 389, 460, 537, 540, 541, 353, 152, 40, 60, 106, + 202, 251, 261, 273, 305, 353, 359, 384, 389, 403, + 540, 591, 594, 152, 353, 389, 540, 152, 353, 389, + 540, 152, 40, 969, 291, 484, 815, 882, 550, 551, + 549, 3, 30, 37, 42, 49, 55, 81, 83, 89, + 101, 132, 171, 173, 176, 177, 194, 209, 222, 223, + 225, 235, 237, 247, 269, 278, 300, 302, 322, 364, + 383, 394, 412, 421, 441, 465, 467, 518, 815, 863, + 864, 906, 912, 985, 990, 815, 419, 544, 545, 518, + 517, 638, 373, 583, 649, 275, 918, 40, 192, 545, + 582, 469, 192, 544, 192, 544, 984, 192, 544, 192, + 544, 89, 923, 152, 483, 90, 129, 308, 424, 192, + 545, 152, 519, 910, 63, 360, 521, 655, 152, 521, + 655, 152, 290, 587, 588, 815, 912, 355, 518, 521, + 4, 160, 290, 438, 508, 509, 547, 593, 596, 905, + 937, 939, 940, 943, 938, 431, 517, 669, 673, 815, + 861, 517, 3, 68, 69, 109, 110, 113, 114, 189, + 190, 253, 254, 255, 256, 257, 258, 259, 260, 263, + 264, 337, 338, 378, 379, 473, 474, 497, 498, 547, + 801, 802, 803, 804, 805, 806, 807, 808, 809, 810, + 811, 812, 813, 866, 867, 761, 762, 815, 544, 815, + 868, 508, 509, 545, 816, 817, 843, 854, 870, 517, + 815, 860, 871, 815, 58, 172, 233, 432, 815, 861, + 874, 815, 518, 546, 517, 421, 717, 718, 718, 700, + 701, 749, 220, 695, 225, 37, 225, 383, 763, 225, + 300, 764, 749, 764, 225, 763, 517, 225, 764, 225, + 148, 200, 751, 225, 718, 517, 546, 517, 718, 297, + 815, 949, 951, 863, 3, 37, 42, 49, 54, 55, + 56, 57, 71, 72, 81, 83, 89, 101, 112, 115, + 165, 171, 173, 177, 194, 209, 216, 217, 219, 222, + 223, 225, 235, 237, 247, 268, 269, 270, 278, 283, + 300, 302, 322, 342, 364, 368, 383, 390, 394, 397, + 412, 421, 429, 430, 441, 447, 464, 467, 777, 779, + 780, 782, 784, 786, 788, 790, 791, 792, 794, 795, + 798, 799, 865, 908, 985, 988, 40, 236, 545, 517, + 515, 680, 466, 797, 815, 880, 797, 797, 517, 517, + 785, 785, 325, 680, 517, 787, 523, 71, 72, 797, + 815, 785, 517, 517, 481, 503, 517, 800, 517, 800, + 815, 815, 815, 148, 892, 893, 815, 861, 862, 680, + 815, 860, 546, 844, 845, 846, 9, 551, 519, 548, + 883, 548, 517, 547, 517, 517, 547, 905, 3, 8, + 11, 15, 16, 17, 18, 19, 20, 21, 36, 40, + 46, 53, 80, 177, 194, 199, 222, 223, 237, 275, + 278, 292, 295, 394, 501, 504, 505, 506, 508, 509, + 510, 511, 512, 513, 852, 853, 854, 856, 886, 480, + 828, 302, 815, 521, 695, 517, 547, 695, 3, 117, + 241, 547, 593, 799, 950, 104, 951, 951, 545, 40, + 545, 518, 521, 936, 521, 518, 693, 899, 900, 40, + 962, 193, 355, 220, 638, 389, 682, 682, 30, 705, + 706, 815, 59, 682, 699, 164, 272, 725, 227, 273, + 341, 392, 454, 4, 9, 30, 720, 815, 508, 509, + 721, 722, 815, 817, 737, 738, 712, 711, 709, 710, + 167, 740, 285, 742, 59, 688, 689, 690, 752, 816, + 890, 890, 709, 737, 861, 911, 172, 468, 955, 236, + 544, 74, 82, 93, 169, 192, 329, 448, 545, 620, + 630, 645, 82, 93, 553, 93, 553, 517, 431, 517, + 618, 245, 451, 618, 93, 521, 431, 544, 3, 782, + 593, 59, 595, 593, 593, 106, 251, 261, 59, 431, + 479, 503, 592, 266, 373, 592, 594, 766, 93, 431, + 553, 373, 544, 431, 373, 968, 545, 669, 516, 527, + 863, 863, 864, 521, 703, 704, 13, 14, 222, 222, + 431, 431, 545, 637, 642, 479, 672, 544, 380, 345, + 384, 419, 469, 658, 152, 100, 579, 603, 919, 920, + 980, 144, 779, 275, 199, 584, 544, 275, 580, 591, + 275, 517, 638, 40, 275, 638, 275, 517, 659, 192, + 545, 632, 924, 551, 152, 172, 598, 654, 550, 519, + 909, 899, 902, 902, 909, 518, 521, 13, 938, 944, + 4, 905, 4, 905, 547, 551, 671, 678, 55, 102, + 123, 141, 145, 168, 171, 187, 280, 288, 310, 339, + 675, 40, 518, 815, 518, 172, 521, 518, 318, 869, + 518, 816, 816, 11, 15, 16, 19, 20, 21, 199, + 222, 292, 504, 505, 506, 508, 509, 510, 511, 512, + 513, 854, 816, 518, 768, 769, 825, 167, 172, 872, + 873, 521, 518, 40, 874, 861, 874, 874, 172, 518, + 40, 760, 517, 900, 4, 9, 545, 713, 715, 716, + 890, 888, 178, 241, 419, 423, 425, 451, 544, 696, + 476, 772, 749, 749, 225, 749, 290, 457, 765, 749, + 225, 890, 749, 749, 282, 282, 517, 749, 546, 773, + 774, 517, 546, 773, 521, 518, 521, 519, 517, 782, + 517, 517, 519, 39, 781, 517, 801, 802, 803, 804, + 805, 806, 807, 808, 809, 810, 811, 812, 813, 814, + 518, 521, 785, 554, 559, 660, 661, 679, 916, 961, + 973, 861, 862, 517, 475, 877, 878, 815, 862, 905, + 815, 847, 848, 849, 850, 797, 797, 8, 15, 16, + 19, 20, 21, 504, 505, 506, 508, 509, 510, 511, + 512, 513, 545, 852, 857, 518, 861, 429, 429, 905, + 905, 517, 545, 355, 897, 167, 516, 518, 521, 527, + 521, 524, 510, 549, 861, 905, 815, 814, 814, 779, + 815, 815, 815, 815, 815, 815, 815, 815, 5, 551, + 913, 429, 45, 416, 887, 909, 815, 815, 517, 680, + 875, 132, 160, 275, 280, 285, 438, 449, 815, 280, + 517, 815, 431, 53, 177, 194, 199, 237, 394, 815, + 815, 815, 815, 815, 815, 815, 815, 815, 815, 30, + 38, 399, 851, 515, 519, 885, 181, 163, 829, 368, + 517, 843, 891, 172, 746, 863, 746, 517, 547, 545, + 544, 957, 544, 965, 815, 521, 518, 250, 275, 694, + 457, 964, 544, 556, 517, 545, 561, 571, 572, 574, + 41, 126, 707, 521, 457, 707, 266, 682, 368, 369, + 508, 509, 722, 724, 817, 392, 227, 291, 313, 313, + 521, 512, 4, 723, 905, 723, 368, 369, 724, 544, + 898, 279, 396, 743, 517, 900, 901, 521, 181, 457, + 199, 181, 220, 738, 710, 518, 545, 547, 545, 547, + 353, 540, 517, 192, 630, 902, 227, 275, 227, 457, + 517, 623, 778, 779, 902, 545, 192, 902, 192, 545, + 26, 137, 389, 536, 539, 551, 614, 628, 902, 551, + 622, 641, 902, 537, 902, 353, 389, 540, 591, 593, + 909, 902, 593, 909, 902, 593, 353, 389, 540, 902, + 902, 902, 902, 353, 389, 540, 902, 902, 547, 509, + 815, 882, 703, 703, 703, 465, 864, 193, 358, 702, + 815, 815, 280, 547, 931, 280, 931, 545, 334, 668, + 518, 521, 288, 172, 431, 663, 918, 582, 469, 544, + 544, 984, 544, 544, 544, 295, 649, 517, 680, 152, + 3, 517, 517, 152, 152, 237, 545, 620, 630, 633, + 636, 646, 648, 479, 481, 625, 151, 679, 152, 479, + 925, 152, 518, 863, 40, 275, 290, 545, 3, 655, + 550, 655, 290, 655, 587, 815, 669, 510, 515, 517, + 593, 670, 821, 822, 943, 518, 521, 40, 667, 547, + 667, 275, 280, 339, 667, 59, 667, 779, 518, 815, + 815, 815, 872, 779, 816, 816, 816, 816, 816, 816, + 132, 275, 285, 816, 816, 816, 816, 816, 816, 816, + 816, 816, 816, 518, 521, 40, 770, 815, 815, 873, + 872, 779, 518, 518, 518, 861, 779, 900, 518, 313, + 512, 313, 369, 512, 517, 517, 695, 423, 425, 423, + 425, 544, 697, 697, 697, 815, 181, 726, 765, 765, + 749, 815, 517, 749, 167, 765, 517, 546, 756, 765, + 779, 518, 521, 773, 518, 949, 3, 865, 39, 781, + 545, 776, 776, 3, 515, 515, 905, 431, 431, 431, + 431, 779, 454, 518, 516, 861, 815, 139, 878, 879, + 518, 518, 518, 527, 521, 524, 519, 518, 518, 500, + 500, 518, 518, 900, 517, 815, 894, 545, 815, 815, + 844, 893, 518, 518, 518, 500, 816, 816, 145, 861, + 172, 132, 160, 280, 285, 438, 449, 517, 145, 857, + 815, 416, 887, 815, 875, 815, 431, 517, 680, 815, + 882, 550, 517, 517, 155, 830, 747, 748, 772, 703, + 772, 905, 814, 911, 911, 250, 517, 748, 476, 963, + 40, 59, 557, 567, 574, 883, 521, 746, 506, 502, + 708, 706, 292, 852, 855, 708, 4, 905, 724, 291, + 454, 721, 521, 244, 900, 688, 59, 890, 517, 546, + 59, 266, 955, 955, 431, 815, 275, 645, 517, 152, + 517, 623, 203, 642, 643, 604, 40, 176, 613, 639, + 604, 26, 137, 357, 359, 389, 533, 534, 535, 541, + 542, 152, 655, 152, 655, 614, 628, 614, 518, 521, + 547, 607, 506, 519, 518, 521, 431, 373, 93, 431, + 553, 373, 431, 431, 431, 373, 969, 527, 516, 527, + 702, 702, 702, 864, 282, 282, 518, 517, 662, 3, + 406, 407, 547, 677, 637, 668, 584, 544, 580, 517, + 40, 638, 659, 918, 355, 419, 547, 576, 577, 582, + 678, 642, 544, 544, 984, 544, 518, 521, 288, 618, + 288, 290, 617, 902, 479, 983, 544, 618, 40, 544, + 518, 419, 815, 152, 544, 598, 909, 665, 676, 943, + 671, 547, 547, 280, 642, 510, 642, 547, 510, 642, + 547, 518, 518, 873, 172, 132, 285, 517, 771, 768, + 517, 518, 518, 518, 545, 713, 772, 697, 697, 697, + 697, 544, 544, 544, 59, 186, 735, 765, 900, 517, + 753, 754, 755, 818, 820, 900, 167, 80, 775, 774, + 518, 518, 515, 779, 518, 521, 518, 905, 516, 905, + 518, 802, 804, 805, 806, 805, 806, 806, 518, 427, + 815, 143, 815, 847, 857, 800, 800, 518, 815, 894, + 895, 896, 40, 199, 518, 897, 814, 815, 36, 36, + 815, 518, 815, 172, 517, 865, 815, 518, 145, 816, + 816, 145, 145, 815, 815, 516, 527, 517, 884, 704, + 476, 815, 301, 834, 521, 726, 702, 726, 518, 916, + 815, 361, 565, 545, 266, 321, 117, 304, 517, 555, + 679, 518, 521, 561, 963, 815, 164, 231, 517, 708, + 291, 544, 518, 901, 181, 680, 681, 890, 901, 902, + 902, 518, 152, 643, 630, 643, 604, 632, 521, 518, + 119, 207, 273, 275, 629, 517, 33, 59, 650, 639, + 74, 80, 93, 117, 119, 207, 275, 280, 329, 347, + 448, 457, 609, 610, 624, 176, 117, 191, 275, 618, + 592, 107, 117, 176, 275, 405, 408, 594, 618, 389, + 535, 442, 902, 545, 539, 3, 37, 42, 49, 55, + 81, 83, 89, 101, 171, 173, 176, 177, 194, 209, + 222, 223, 225, 235, 237, 247, 269, 274, 278, 292, + 300, 302, 322, 364, 383, 390, 394, 412, 421, 441, + 447, 467, 508, 509, 547, 593, 605, 644, 779, 855, + 906, 985, 991, 551, 641, 902, 902, 902, 902, 902, + 902, 902, 902, 902, 902, 669, 882, 882, 518, 518, + 518, 703, 107, 373, 519, 592, 677, 517, 517, 636, + 679, 925, 40, 649, 192, 544, 518, 521, 584, 518, + 518, 580, 517, 40, 627, 625, 633, 86, 589, 107, + 273, 638, 679, 659, 679, 632, 457, 922, 655, 518, + 521, 642, 816, 172, 517, 865, 773, 518, 521, 518, + 726, 544, 544, 544, 544, 30, 103, 182, 367, 517, + 727, 728, 729, 730, 731, 732, 733, 815, 815, 478, + 831, 518, 817, 858, 859, 199, 181, 750, 754, 518, + 756, 757, 758, 909, 781, 905, 781, 545, 781, 516, + 516, 815, 521, 518, 545, 815, 817, 815, 815, 815, + 865, 518, 815, 36, 36, 815, 815, 145, 518, 509, + 882, 518, 863, 518, 815, 518, 517, 545, 835, 735, + 518, 735, 547, 518, 889, 463, 418, 456, 566, 545, + 560, 570, 290, 563, 506, 574, 565, 857, 59, 518, + 518, 462, 463, 685, 604, 630, 518, 518, 479, 635, + 120, 195, 205, 119, 459, 815, 117, 40, 517, 909, + 902, 816, 120, 195, 119, 280, 227, 544, 635, 88, + 650, 192, 280, 593, 815, 650, 280, 508, 509, 596, + 545, 779, 655, 655, 3, 247, 412, 906, 910, 506, + 431, 431, 516, 516, 702, 518, 518, 545, 669, 457, + 664, 666, 678, 642, 518, 983, 40, 419, 815, 419, + 275, 517, 547, 517, 925, 636, 151, 679, 149, 201, + 617, 122, 137, 328, 983, 107, 925, 479, 981, 40, + 290, 545, 921, 517, 676, 816, 865, 518, 518, 9, + 354, 719, 735, 517, 391, 517, 518, 521, 545, 832, + 833, 336, 736, 521, 518, 517, 546, 59, 518, 199, + 518, 757, 516, 779, 894, 516, 192, 518, 815, 815, + 815, 527, 516, 527, 518, 518, 545, 836, 831, 547, + 831, 521, 462, 883, 518, 521, 91, 565, 815, 518, + 901, 901, 347, 635, 517, 626, 604, 518, 191, 517, + 815, 275, 610, 635, 638, 902, 40, 152, 775, 910, + 512, 605, 902, 902, 518, 592, 124, 518, 518, 625, + 679, 679, 544, 152, 678, 40, 518, 902, 983, 30, + 85, 94, 118, 191, 204, 405, 408, 621, 621, 369, + 369, 40, 64, 74, 241, 419, 815, 544, 517, 545, + 564, 573, 825, 518, 518, 517, 831, 861, 517, 861, + 729, 40, 521, 815, 457, 714, 817, 890, 900, 761, + 517, 761, 815, 882, 882, 310, 837, 736, 736, 679, + 304, 679, 560, 290, 517, 558, 544, 604, 551, 631, + 634, 409, 471, 611, 612, 517, 606, 815, 518, 249, + 647, 191, 457, 538, 512, 442, 669, 547, 925, 617, + 981, 517, 544, 518, 679, 625, 589, 679, 74, 293, + 74, 679, 922, 815, 80, 568, 518, 521, 568, 9, + 736, 518, 728, 518, 835, 833, 371, 518, 890, 516, + 516, 516, 59, 703, 714, 714, 566, 93, 573, 133, + 638, 506, 518, 521, 591, 518, 273, 619, 173, 309, + 395, 290, 615, 616, 640, 606, 815, 442, 40, 517, + 981, 617, 983, 981, 293, 293, 517, 518, 909, 569, + 909, 925, 564, 569, 518, 714, 518, 716, 518, 860, + 184, 340, 369, 838, 462, 902, 518, 276, 454, 647, + 605, 634, 518, 612, 205, 122, 454, 290, 640, 290, + 615, 679, 573, 568, 707, 772, 707, 53, 104, 444, + 815, 839, 840, 839, 839, 518, 679, 772, 389, 616, + 63, 273, 360, 389, 608, 608, 981, 518, 569, 708, + 708, 840, 368, 166, 324, 166, 324, 148, 841, 841, + 841, 572, 604, 25, 117, 280, 925, 707, 36, 104, + 181, 273, 428, 772, 772, 708, 840, 368, 298 }; -/* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */ -static const yytype_int16 yyr1[] = -{ - 0, 528, 529, 530, 530, 531, 531, 531, 531, 531, - 531, 531, 531, 531, 531, 531, 531, 531, 531, 531, - 531, 531, 531, 531, 531, 531, 531, 531, 531, 531, - 531, 531, 531, 531, 531, 531, 531, 531, 531, 531, - 531, 531, 531, 531, 531, 531, 531, 540, 540, 540, - 540, 540, 540, 540, 540, 541, 541, 542, 542, 543, - 543, 543, 543, 544, 544, 545, 545, 545, 545, 545, - 545, 545, 545, 545, 545, 545, 545, 545, 545, 545, - 545, 545, 545, 545, 545, 545, 545, 545, 545, 545, - 545, 545, 545, 545, 546, 546, 547, 547, 547, 547, - 548, 548, 549, 550, 550, 550, 661, 661, 661, 661, - 562, 562, 563, 563, 563, 564, 564, 565, 566, 566, - 567, 568, 569, 569, 569, 569, 727, 727, 727, 727, - 727, 727, 727, 727, 727, 727, 727, 727, 727, 728, - 728, 698, 699, 699, 699, 699, 699, 700, 700, 701, - 701, 701, 702, 702, 702, 703, 703, 704, 705, 705, - 706, 706, 706, 707, 707, 707, 708, 708, 708, 709, - 709, 710, 710, 711, 711, 712, 712, 713, 713, 714, - 714, 715, 715, 716, 716, 717, 717, 718, 658, 658, - 658, 659, 659, 660, 660, 723, 723, 723, 656, 656, - 656, 657, 657, 652, 652, 652, 653, 653, 654, 654, - 654, 655, 655, 967, 674, 674, 674, 675, 675, 676, - 676, 677, 677, 533, 533, 534, 534, 535, 535, 535, - 536, 536, 536, 536, 537, 537, 537, 537, 537, 537, - 537, 537, 537, 537, 537, 537, 537, 537, 538, 538, - 539, 539, 539, 672, 672, 673, 673, 964, 964, 964, - 964, 964, 964, 965, 965, 965, 968, 588, 588, 588, - 589, 589, 590, 590, 590, 590, 590, 590, 591, 591, - 592, 593, 593, 593, 593, 593, 594, 594, 594, 594, - 595, 595, 595, 595, 595, 595, 595, 595, 596, 596, - 597, 597, 598, 598, 598, 599, 600, 601, 601, 601, - 601, 601, 602, 602, 602, 602, 603, 604, 604, 605, - 605, 606, 606, 606, 606, 606, 606, 606, 606, 607, - 607, 608, 609, 609, 609, 609, 610, 610, 610, 610, - 611, 612, 612, 612, 613, 614, 614, 614, 614, 614, - 614, 615, 615, 616, 616, 617, 618, 618, 618, 619, - 619, 620, 620, 621, 621, 621, 622, 623, 623, 624, - 624, 625, 626, 626, 626, 626, 627, 627, 628, 628, - 629, 629, 629, 630, 630, 630, 630, 630, 630, 631, - 631, 632, 632, 632, 632, 633, 634, 634, 634, 634, - 634, 634, 634, 634, 635, 635, 666, 666, 666, 666, - 666, 666, 667, 667, 667, 667, 667, 667, 667, 667, - 667, 667, 667, 667, 667, 667, 667, 667, 667, 667, - 668, 668, 668, 668, 668, 668, 669, 669, 670, 670, - 670, 671, 671, 671, 646, 646, 646, 646, 646, 646, - 647, 647, 648, 648, 966, 570, 570, 570, 571, 571, - 571, 572, 572, 573, 573, 574, 574, 575, 575, 576, - 576, 577, 577, 578, 578, 579, 579, 579, 579, 579, - 579, 579, 580, 581, 581, 582, 582, 583, 583, 584, - 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, - 584, 584, 584, 584, 584, 585, 586, 586, 586, 586, - 586, 587, 587, 729, 729, 730, 730, 730, 731, 731, - 731, 731, 731, 731, 731, 731, 732, 732, 733, 733, - 734, 734, 734, 734, 734, 734, 734, 734, 734, 734, - 734, 734, 734, 734, 734, 734, 734, 734, 734, 735, - 735, 736, 736, 737, 737, 738, 738, 738, 739, 739, - 740, 740, 741, 741, 741, 742, 742, 743, 744, 744, - 744, 745, 745, 746, 746, 746, 746, 746, 746, 746, - 746, 746, 747, 747, 748, 748, 748, 749, 750, 750, - 751, 751, 752, 752, 752, 753, 753, 754, 754, 755, - 755, 756, 756, 757, 757, 757, 758, 758, 758, 759, - 759, 759, 759, 760, 760, 761, 761, 761, 761, 762, - 762, 763, 763, 763, 763, 763, 763, 764, 764, 765, - 765, 766, 766, 766, 766, 767, 768, 768, 769, 769, - 770, 770, 770, 770, 770, 771, 772, 772, 772, 773, - 773, 774, 774, 775, 775, 776, 776, 776, 777, 777, - 778, 778, 779, 779, 779, 779, 779, 780, 781, 782, - 783, 784, 784, 785, 785, 786, 786, 787, 787, 788, - 788, 789, 789, 790, 791, 791, 791, 791, 792, 792, - 793, 793, 793, 794, 794, 795, 795, 796, 796, 797, - 797, 798, 798, 799, 799, 799, 799, 799, 799, 799, - 799, 799, 799, 800, 800, 801, 801, 801, 802, 802, - 803, 803, 803, 803, 804, 804, 805, 805, 806, 806, - 807, 808, 808, 809, 809, 809, 809, 809, 809, 809, - 809, 809, 809, 809, 810, 810, 810, 810, 811, 811, - 812, 812, 812, 812, 812, 813, 813, 813, 813, 813, - 813, 814, 814, 815, 815, 816, 816, 816, 816, 817, - 817, 818, 819, 819, 820, 820, 821, 821, 822, 822, - 823, 823, 824, 825, 825, 826, 826, 827, 827, 828, - 828, 829, 829, 829, 829, 829, 829, 829, 829, 829, - 829, 830, 830, 831, 831, 831, 832, 832, 832, 832, - 832, 832, 832, 833, 833, 833, 833, 834, 835, 835, - 836, 836, 836, 836, 836, 836, 836, 836, 836, 836, - 836, 837, 837, 838, 838, 839, 839, 840, 841, 842, - 842, 843, 843, 844, 845, 846, 846, 846, 846, 846, - 846, 847, 847, 848, 848, 848, 848, 849, 850, 850, - 850, 851, 851, 852, 852, 853, 853, 854, 854, 855, - 855, 856, 856, 857, 857, 858, 858, 859, 859, 860, - 860, 861, 861, 862, 862, 863, 863, 864, 864, 864, - 864, 864, 864, 864, 864, 864, 864, 864, 864, 864, - 864, 864, 864, 864, 864, 864, 864, 864, 865, 865, - 865, 865, 865, 865, 865, 865, 865, 865, 865, 865, - 865, 865, 865, 865, 865, 865, 865, 865, 865, 865, - 865, 865, 865, 865, 865, 865, 865, 865, 865, 865, - 865, 865, 865, 865, 865, 865, 865, 865, 865, 865, - 865, 865, 865, 865, 865, 865, 865, 865, 865, 865, - 865, 865, 865, 865, 865, 865, 865, 865, 865, 865, - 865, 865, 865, 865, 865, 865, 865, 865, 866, 866, - 866, 866, 866, 866, 866, 866, 866, 866, 866, 866, - 866, 866, 866, 866, 866, 866, 866, 866, 866, 866, - 866, 866, 866, 867, 867, 868, 868, 868, 868, 868, - 868, 869, 869, 869, 870, 870, 870, 870, 870, 870, - 870, 870, 870, 870, 870, 870, 871, 872, 873, 873, - 873, 873, 873, 873, 874, 874, 875, 875, 876, 876, - 876, 876, 876, 876, 876, 876, 876, 876, 876, 876, - 876, 876, 877, 877, 878, 878, 879, 879, 879, 880, - 880, 881, 881, 882, 882, 883, 884, 884, 884, 885, - 886, 886, 887, 887, 888, 888, 888, 888, 889, 889, - 890, 890, 890, 890, 890, 891, 891, 891, 891, 891, - 892, 892, 893, 893, 894, 895, 895, 896, 896, 897, - 898, 898, 899, 899, 900, 900, 901, 901, 901, 902, - 902, 903, 903, 903, 903, 903, 903, 903, 903, 903, - 903, 903, 903, 903, 903, 904, 904, 905, 905, 906, - 906, 906, 906, 906, 906, 906, 906, 907, 907, 908, - 908, 909, 909, 910, 910, 911, 911, 912, 912, 913, - 913, 914, 914, 914, 915, 915, 916, 916, 917, 917, - 917, 917, 917, 917, 917, 917, 917, 917, 917, 917, - 917, 917, 917, 918, 918, 919, 920, 920, 921, 921, - 921, 921, 921, 921, 922, 923, 924, 924, 924, 925, - 925, 926, 927, 927, 928, 929, 929, 930, 930, 931, - 931, 567, 567, 567, 567, 932, 932, 933, 933, 934, - 934, 934, 935, 935, 935, 935, 935, 936, 936, 937, - 937, 938, 938, 939, 939, 940, 940, 941, 941, 941, - 942, 942, 943, 943, 944, 945, 945, 946, 946, 947, - 947, 947, 948, 948, 949, 949, 950, 950, 951, 951, - 952, 953, 953, 954, 954, 954, 954, 954, 954, 954, - 954, 954, 954, 954, 954, 954, 954, 955, 956, 956, - 956, 957, 957, 957, 958, 958, 958, 959, 959, 960, - 960, 961, 961, 962, 963, 963, 724, 725, 725, 726, - 726, 726, 726, 726, 726, 649, 649, 649, 650, 650, - 651, 651, 651, 651, 691, 691, 692, 693, 693, 694, - 694, 695, 695, 696, 696, 697, 697, 532, 532, 532, - 532, 532, 532, 557, 557, 558, 558, 559, 559, 560, - 560, 561, 561, 561, 561, 561, 561, 561, 561, 561, - 561, 689, 689, 690, 678, 678, 678, 678, 679, 679, - 680, 680, 680, 681, 681, 681, 681, 681, 681, 681, - 681, 681, 681, 681, 681, 681, 681, 681, 681, 681, - 681, 681, 681, 681, 681, 681, 681, 681, 681, 681, - 681, 681, 681, 681, 682, 682, 682, 683, 683, 684, - 684, 685, 685, 686, 686, 686, 686, 687, 688, 688, - 977, 977, 977, 977, 978, 978, 978, 978, 979, 979, - 980, 981, 981, 981, 981, 981, 981, 981, 982, 982, - 719, 719, 719, 719, 720, 720, 721, 721, 722, 722, - 722, 969, 969, 969, 969, 969, 970, 970, 970, 970, - 970, 971, 971, 972, 972, 973, 973, 662, 662, 663, - 663, 663, 664, 664, 665, 665, 551, 551, 552, 552, - 553, 553, 553, 554, 554, 555, 555, 974, 974, 974, - 974, 975, 975, 976, 976, 976, 983, 983, 983, 983, - 983, 983, 983, 983, 984, 984, 985, 985, 986, 986, - 987, 987, 988, 988, 556, 989, 989, 989, 989, 989, - 990, 990, 990, 990, 636, 636, 636, 637, 637, 637, - 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, - 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, - 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, 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, 643, 643, 643, 643, 643, - 643, 643, 643, 643, 643, 643, 643, 643, 643, 643, - 643, 643, 643, 643, 643, 643, 643, 643, 643, 643, - 643, 643, 643, 643, 643, 643, 643, 643, 643, 643, - 643, 643, 643, 643, 643, 643, 643, 643, 643, 643, - 643, 643, 643, 643, 643, 643, 643, 643, 643, 643, - 643, 643, 643, 643, 643, 643, 643, 643, 643, 643, - 643, 643, 643, 643, 643, 643, 643, 643, 643, 643, - 643, 643, 643, 643, 643, 643, 644, 644, 644, 644, - 644, 644, 644, 644, 644, 644, 644, 644, 644, 644, - 644, 644, 644, 644, 644, 644, 644, 644, 644, 644, - 644, 644, 644, 644, 644, 644, 644, 644, 645, 645, - 645, 645, 645, 645, 645, 645, 645, 645, 645, 645, - 645, 645, 645, 645, 645, 645, 645, 645, 645, 645, - 645, 645, 645, 645, 645, 645, 645, 645, 645, 645, - 645, 645, 645, 645, 645, 645, 645, 645, 645, 645, - 645, 645, 645, 645, 645, 645, 645, 645, 645, 645, - 645, 645, 645, 645, 645, 645, 645, 645, 645, 645, - 645, 645, 645, 645, 645, 645, 645, 645, 645, 645, - 645, 645, 645 -}; +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY (-2) +#define YYEOF 0 -/* 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, 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, 4, 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, 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, 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, - 1, 1, 2, 4, 2, 2, 3, 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, 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, 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, 4, 6, 6, 0, 1, 1, 1, 0, 2, - 2, 4, 6, 5, 4, 6, 1, 1, 1, 1, - 1, 1, 0, 1, 3, 1, 0, 7, 3, 1, - 2, 3, 2, 0, 2, 0, 2, 4, 5, 8, - 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, - 1, 1, 1 -}; +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab -enum { YYENOMEM = -2 }; +/* 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 yyerrok (yyerrstatus = 0) -#define yyclearin (yychar = YYEMPTY) +#define YYFAIL goto yyerrlab -#define YYACCEPT goto yyacceptlab -#define YYABORT goto yyabortlab -#define YYERROR goto yyerrorlab -#define YYNOMEM goto yyexhaustedlab +#define YYRECOVERING() (!!yyerrstatus) +#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 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 +#define YYTERROR 1 +#define YYERRCODE 256 + /* 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 -#define YYRHSLOC(Rhs, K) ((Rhs)[K]) - - -/* Enable debugging if requested. */ -#if YYDEBUG - -# ifndef YYFPRINTF -# include /* INFRINGES ON USER NAME SPACE */ -# define YYFPRINTF fprintf -# endif -# define YYDPRINTF(Args) \ -do { \ - if (yydebug) \ - YYFPRINTF Args; \ -} while (0) - - -/* YYLOCATION_PRINT -- Print the location on the stream. +/* 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 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 +#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 -# endif -# endif /* !defined YYLOCATION_PRINT */ +/* YYLEX -- calling `yylex' with the right arguments. */ -# 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) +#ifdef YYLEX_PARAM +# define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM) +#else +# define YYLEX yylex (&yylval, &yylloc, yyscanner) +#endif +/* Enable debugging if requested. */ +#if YYDEBUG -/*-----------------------------------. -| Print this symbol's value on YYO. | -`-----------------------------------*/ +# ifndef YYFPRINTF +# include /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif +# 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 *yyo, - yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, core_yyscan_t yyscanner) +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 (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, ")"); } /*------------------------------------------------------------------. @@ -18732,69 +19515,82 @@ yy_symbol_print (FILE *yyo, | TOP (included). | `------------------------------------------------------------------*/ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) static void -yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop) +yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) +#else +static void +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 (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, core_yyscan_t yyscanner) +#else static void -yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp, - int yyrule, core_yyscan_t yyscanner) +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 @@ -18809,30 +19605,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 */ @@ -18843,217 +19879,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); +/* Number of syntax errors so far. */ +int yynerrs; +/* Location data for the look-ahead symbol. */ +YYLTYPE yylloc; -/* 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; + 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 - /* Number of syntax errors so far. */ - int yynerrs = 0; (void)yynerrs; + /* Three stacks and their tools: + `yyss': related to states, + `yyvs': related to semantic values, + `yyls': related to locations. - yy_state_fast_t yystate = 0; - /* Number of tokens to shift before error messages enabled. */ - int yyerrstatus = 0; + Refer to the stacks thru separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ - /* Refer to the stacks through separate pointers, to allow yyoverflow - to reallocate them elsewhere. */ + /* The state stack. */ + yytype_int16 yyssa[YYINITDEPTH]; + yytype_int16 *yyss = yyssa; + yytype_int16 *yyssp; - /* Their size. */ - YYPTRDIFF_T yystacksize = YYINITDEPTH; + /* The semantic value stack. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs = yyvsa; + YYSTYPE *yyvsp; - /* The state stack: array, bottom, top. */ - yy_state_t yyssa[YYINITDEPTH]; - yy_state_t *yyss = yyssa; - yy_state_t *yyssp = yyss; + /* 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. */ + + /* 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 - yylsp[0] = yylloc; 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); @@ -19068,27 +20108,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; @@ -19103,14 +20146,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 @@ -19119,2366 +20162,2140 @@ 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 */ -#line 505 "third_party/libpg_query/grammar/grammar.y" - { - pg_yyget_extra(yyscanner)->parsetree = (yyvsp[0].list); - } -#line 19134 "third_party/libpg_query/grammar/grammar_out.cpp" + case 2: +#line 507 "third_party/libpg_query/grammar/grammar.y" + { + pg_yyget_extra(yyscanner)->parsetree = (yyvsp[(1) - (1)].list); + ;} break; - case 3: /* stmtmulti: stmtmulti ';' stmt */ -#line 521 "third_party/libpg_query/grammar/grammar.y" - { - if ((yyvsp[-2].list) != NIL) + case 3: +#line 523 "third_party/libpg_query/grammar/grammar.y" + { + 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 19150 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.list) = (yyvsp[(1) - (3)].list); + ;} break; - case 4: /* stmtmulti: stmt */ -#line 533 "third_party/libpg_query/grammar/grammar.y" - { - if ((yyvsp[0].node) != NULL) - (yyval.list) = list_make1(makeRawStmt((yyvsp[0].node), 0)); + case 4: +#line 535 "third_party/libpg_query/grammar/grammar.y" + { + if ((yyvsp[(1) - (1)].node) != NULL) + (yyval.list) = list_make1(makeRawStmt((yyvsp[(1) - (1)].node), 0)); else (yyval.list) = NIL; - } -#line 19161 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 46: /* stmt: %empty */ -#line 583 "third_party/libpg_query/grammar/grammar.y" - { (yyval.node) = NULL; } -#line 19167 "third_party/libpg_query/grammar/grammar_out.cpp" + case 46: +#line 585 "third_party/libpg_query/grammar/grammar.y" + { (yyval.node) = NULL; ;} break; - case 47: /* AlterTableStmt: ALTER TABLE relation_expr alter_table_cmds */ + case 47: #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 19180 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 48: /* AlterTableStmt: ALTER TABLE IF_P EXISTS relation_expr alter_table_cmds */ + case 48: #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 19193 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 49: /* AlterTableStmt: ALTER INDEX qualified_name alter_table_cmds */ + case 49: #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 19206 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 50: /* AlterTableStmt: ALTER INDEX IF_P EXISTS qualified_name alter_table_cmds */ + case 50: #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 19219 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 51: /* AlterTableStmt: ALTER SEQUENCE qualified_name alter_table_cmds */ + case 51: #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 19232 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 52: /* AlterTableStmt: ALTER SEQUENCE IF_P EXISTS qualified_name alter_table_cmds */ + case 52: #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 19245 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 53: /* AlterTableStmt: ALTER VIEW qualified_name alter_table_cmds */ + case 53: #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 19258 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 54: /* AlterTableStmt: ALTER VIEW IF_P EXISTS qualified_name alter_table_cmds */ + case 54: #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 19271 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 55: /* alter_identity_column_option_list: alter_identity_column_option */ + case 55: #line 86 "third_party/libpg_query/grammar/statements/alter_table.y" - { (yyval.list) = list_make1((yyvsp[0].defelt)); } -#line 19277 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); ;} break; - case 56: /* alter_identity_column_option_list: alter_identity_column_option_list alter_identity_column_option */ + case 56: #line 88 "third_party/libpg_query/grammar/statements/alter_table.y" - { (yyval.list) = lappend((yyvsp[-1].list), (yyvsp[0].defelt)); } -#line 19283 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].defelt)); ;} break; - case 57: /* alter_column_default: SET DEFAULT a_expr */ + case 57: #line 93 "third_party/libpg_query/grammar/statements/alter_table.y" - { (yyval.node) = (yyvsp[0].node); } -#line 19289 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(3) - (3)].node); ;} break; - case 58: /* alter_column_default: DROP DEFAULT */ + case 58: #line 94 "third_party/libpg_query/grammar/statements/alter_table.y" - { (yyval.node) = NULL; } -#line 19295 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = NULL; ;} break; - case 59: /* alter_identity_column_option: RESTART */ + case 59: #line 100 "third_party/libpg_query/grammar/statements/alter_table.y" - { - (yyval.defelt) = makeDefElem("restart", NULL, (yylsp[0])); - } -#line 19303 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("restart", NULL, (yylsp[(1) - (1)])); + ;} break; - case 60: /* alter_identity_column_option: RESTART opt_with NumericOnly */ + case 60: #line 104 "third_party/libpg_query/grammar/statements/alter_table.y" - { - (yyval.defelt) = makeDefElem("restart", (PGNode *)(yyvsp[0].value), (yylsp[-2])); - } -#line 19311 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("restart", (PGNode *)(yyvsp[(3) - (3)].value), (yylsp[(1) - (3)])); + ;} break; - case 61: /* alter_identity_column_option: SET SeqOptElem */ + case 61: #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 19326 "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 62: /* alter_identity_column_option: SET GENERATED generated_when */ + case 62: #line 119 "third_party/libpg_query/grammar/statements/alter_table.y" - { - (yyval.defelt) = makeDefElem("generated", (PGNode *) makeInteger((yyvsp[0].ival)), (yylsp[-2])); - } -#line 19334 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("generated", (PGNode *) makeInteger((yyvsp[(3) - (3)].ival)), (yylsp[(1) - (3)])); + ;} break; - case 63: /* alter_generic_option_list: alter_generic_option_elem */ + case 63: #line 127 "third_party/libpg_query/grammar/statements/alter_table.y" - { - (yyval.list) = list_make1((yyvsp[0].defelt)); - } -#line 19342 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); + ;} break; - case 64: /* alter_generic_option_list: alter_generic_option_list ',' alter_generic_option_elem */ + case 64: #line 131 "third_party/libpg_query/grammar/statements/alter_table.y" - { - (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].defelt)); - } -#line 19350 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt)); + ;} break; - case 65: /* alter_table_cmd: ADD_P columnDef */ + case 65: #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 19362 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 66: /* alter_table_cmd: ADD_P IF_P NOT EXISTS columnDef */ + case 66: #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 19374 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 67: /* alter_table_cmd: ADD_P COLUMN columnDef */ + case 67: #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 19386 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 68: /* alter_table_cmd: ADD_P COLUMN IF_P NOT EXISTS columnDef */ + case 68: #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 19398 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 69: /* alter_table_cmd: ALTER opt_column ColId alter_column_default */ + case 69: #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 19410 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 70: /* alter_table_cmd: ALTER opt_column ColId DROP NOT NULL_P */ + case 70: #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 19421 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 71: /* alter_table_cmd: ALTER opt_column ColId SET NOT NULL_P */ + case 71: #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 19432 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 72: /* alter_table_cmd: ALTER opt_column ColId SET STATISTICS SignedIconst */ + case 72: #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 19444 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 73: /* alter_table_cmd: ALTER opt_column ColId SET reloptions */ + case 73: #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 19456 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 74: /* alter_table_cmd: ALTER opt_column ColId RESET reloptions */ + case 74: #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 19468 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 75: /* alter_table_cmd: ALTER opt_column ColId SET STORAGE ColId */ + case 75: #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 19480 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 76: /* alter_table_cmd: ALTER opt_column ColId ADD_P GENERATED generated_when AS IDENTITY_P OptParenthesizedSeqOptList */ + case 76: #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 19500 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 77: /* alter_table_cmd: ALTER opt_column ColId alter_identity_column_option_list */ + case 77: #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 19512 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 78: /* alter_table_cmd: ALTER opt_column ColId DROP IDENTITY_P */ + case 78: #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 19524 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 79: /* alter_table_cmd: ALTER opt_column ColId DROP IDENTITY_P IF_P EXISTS */ + case 79: #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 19536 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 80: /* alter_table_cmd: DROP opt_column IF_P EXISTS ColId opt_drop_behavior */ + case 80: #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 19549 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 81: /* alter_table_cmd: DROP opt_column ColId opt_drop_behavior */ + case 81: #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 19562 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 82: /* alter_table_cmd: ALTER opt_column ColId opt_set_data TYPE_P Typename opt_collate_clause alter_using */ + case 82: #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 19580 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 83: /* alter_table_cmd: ALTER opt_column ColId alter_generic_options */ + case 83: #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 19592 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 84: /* alter_table_cmd: ADD_P TableConstraint */ + case 84: #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 19603 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 85: /* alter_table_cmd: ALTER CONSTRAINT name ConstraintAttributeSpec */ + case 85: #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 19621 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 86: /* alter_table_cmd: VALIDATE CONSTRAINT name */ + case 86: #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 19632 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 87: /* alter_table_cmd: DROP CONSTRAINT IF_P EXISTS name opt_drop_behavior */ + case 87: #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 19645 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 88: /* alter_table_cmd: DROP CONSTRAINT name opt_drop_behavior */ + case 88: #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 19658 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 89: /* alter_table_cmd: SET LOGGED */ + case 89: #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 19668 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 90: /* alter_table_cmd: SET UNLOGGED */ + case 90: #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 19678 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 91: /* alter_table_cmd: SET reloptions */ + case 91: #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 19689 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 92: /* alter_table_cmd: RESET reloptions */ + case 92: #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 19700 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 93: /* alter_table_cmd: alter_generic_options */ + case 93: #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 19711 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 94: /* alter_using: USING a_expr */ + case 94: #line 418 "third_party/libpg_query/grammar/statements/alter_table.y" - { (yyval.node) = (yyvsp[0].node); } -#line 19717 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 95: /* alter_using: %empty */ + case 95: #line 419 "third_party/libpg_query/grammar/statements/alter_table.y" - { (yyval.node) = NULL; } -#line 19723 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = NULL; ;} break; - case 96: /* alter_generic_option_elem: generic_option_elem */ + case 96: #line 425 "third_party/libpg_query/grammar/statements/alter_table.y" - { - (yyval.defelt) = (yyvsp[0].defelt); - } -#line 19731 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = (yyvsp[(1) - (1)].defelt); + ;} break; - case 97: /* alter_generic_option_elem: SET generic_option_elem */ + case 97: #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 19740 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 98: /* alter_generic_option_elem: ADD_P generic_option_elem */ + case 98: #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 19749 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 99: /* alter_generic_option_elem: DROP generic_option_name */ + case 99: #line 439 "third_party/libpg_query/grammar/statements/alter_table.y" - { - (yyval.defelt) = makeDefElemExtended(NULL, (yyvsp[0].str), NULL, DEFELEM_DROP, (yylsp[0])); - } -#line 19757 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElemExtended(NULL, (yyvsp[(2) - (2)].str), NULL, DEFELEM_DROP, (yylsp[(2) - (2)])); + ;} break; - case 100: /* alter_table_cmds: alter_table_cmd */ + case 100: #line 446 "third_party/libpg_query/grammar/statements/alter_table.y" - { (yyval.list) = list_make1((yyvsp[0].node)); } -#line 19763 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 101: /* alter_table_cmds: alter_table_cmds ',' alter_table_cmd */ + case 101: #line 447 "third_party/libpg_query/grammar/statements/alter_table.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].node)); } -#line 19769 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; - case 102: /* alter_generic_options: OPTIONS '(' alter_generic_option_list ')' */ + case 102: #line 452 "third_party/libpg_query/grammar/statements/alter_table.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 19775 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; - case 103: /* opt_set_data: SET DATA_P */ + case 103: #line 456 "third_party/libpg_query/grammar/statements/alter_table.y" - { (yyval.ival) = 1; } -#line 19781 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = 1; ;} break; - case 104: /* opt_set_data: SET */ + case 104: #line 457 "third_party/libpg_query/grammar/statements/alter_table.y" - { (yyval.ival) = 0; } -#line 19787 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = 0; ;} break; - case 105: /* opt_set_data: %empty */ + case 105: #line 458 "third_party/libpg_query/grammar/statements/alter_table.y" - { (yyval.ival) = 0; } -#line 19793 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = 0; ;} break; - case 106: /* DeallocateStmt: DEALLOCATE name */ + case 106: #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 19803 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 107: /* DeallocateStmt: DEALLOCATE PREPARE name */ + case 107: #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 19813 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 108: /* DeallocateStmt: DEALLOCATE ALL */ + case 108: #line 20 "third_party/libpg_query/grammar/statements/deallocate.y" - { + { PGDeallocateStmt *n = makeNode(PGDeallocateStmt); n->name = NULL; (yyval.node) = (PGNode *) n; - } -#line 19823 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 109: /* DeallocateStmt: DEALLOCATE PREPARE ALL */ + case 109: #line 26 "third_party/libpg_query/grammar/statements/deallocate.y" - { + { PGDeallocateStmt *n = makeNode(PGDeallocateStmt); n->name = NULL; (yyval.node) = (PGNode *) n; - } -#line 19833 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 110: /* qualified_name: ColIdOrString */ + case 110: #line 10 "third_party/libpg_query/grammar/statements/common.y" - { - (yyval.range) = makeRangeVar(NULL, (yyvsp[0].str), (yylsp[0])); - } -#line 19841 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.range) = makeRangeVar(NULL, (yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); + ;} break; - case 111: /* qualified_name: ColId indirection */ + case 111: #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 19871 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 112: /* ColId: IDENT */ + case 112: #line 44 "third_party/libpg_query/grammar/statements/common.y" - { (yyval.str) = (yyvsp[0].str); } -#line 19877 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 113: /* ColId: unreserved_keyword */ + case 113: #line 45 "third_party/libpg_query/grammar/statements/common.y" - { (yyval.str) = pstrdup((yyvsp[0].keyword)); } -#line 19883 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 114: /* ColId: col_name_keyword */ + case 114: #line 46 "third_party/libpg_query/grammar/statements/common.y" - { (yyval.str) = pstrdup((yyvsp[0].keyword)); } -#line 19889 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 115: /* ColIdOrString: ColId */ + case 115: #line 50 "third_party/libpg_query/grammar/statements/common.y" - { (yyval.str) = (yyvsp[0].str); } -#line 19895 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 116: /* ColIdOrString: SCONST */ + case 116: #line 51 "third_party/libpg_query/grammar/statements/common.y" - { (yyval.str) = (yyvsp[0].str); } -#line 19901 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 117: /* Sconst: SCONST */ + case 117: #line 55 "third_party/libpg_query/grammar/statements/common.y" - { (yyval.str) = (yyvsp[0].str); } -#line 19907 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 118: /* indirection: indirection_el */ + case 118: #line 59 "third_party/libpg_query/grammar/statements/common.y" - { (yyval.list) = list_make1((yyvsp[0].node)); } -#line 19913 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 119: /* indirection: indirection indirection_el */ + case 119: #line 60 "third_party/libpg_query/grammar/statements/common.y" - { (yyval.list) = lappend((yyvsp[-1].list), (yyvsp[0].node)); } -#line 19919 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;} break; - case 120: /* indirection_el: '.' attr_name */ + case 120: #line 65 "third_party/libpg_query/grammar/statements/common.y" - { - (yyval.node) = (PGNode *) makeString((yyvsp[0].str)); - } -#line 19927 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (PGNode *) makeString((yyvsp[(2) - (2)].str)); + ;} break; - case 121: /* attr_name: ColLabel */ + case 121: #line 70 "third_party/libpg_query/grammar/statements/common.y" - { (yyval.str) = (yyvsp[0].str); } -#line 19933 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 122: /* ColLabel: IDENT */ + case 122: #line 75 "third_party/libpg_query/grammar/statements/common.y" - { (yyval.str) = (yyvsp[0].str); } -#line 19939 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 123: /* ColLabel: other_keyword */ + case 123: #line 76 "third_party/libpg_query/grammar/statements/common.y" - { (yyval.str) = pstrdup((yyvsp[0].keyword)); } -#line 19945 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 124: /* ColLabel: unreserved_keyword */ + case 124: #line 77 "third_party/libpg_query/grammar/statements/common.y" - { (yyval.str) = pstrdup((yyvsp[0].keyword)); } -#line 19951 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 125: /* ColLabel: reserved_keyword */ + case 125: #line 78 "third_party/libpg_query/grammar/statements/common.y" - { (yyval.str) = pstrdup((yyvsp[0].keyword)); } -#line 19957 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 126: /* RenameStmt: ALTER SCHEMA name RENAME TO name */ + case 126: #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 19970 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 127: /* RenameStmt: ALTER TABLE relation_expr RENAME TO name */ + case 127: #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 19984 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 128: /* RenameStmt: ALTER TABLE IF_P EXISTS relation_expr RENAME TO name */ + case 128: #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 19998 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 129: /* RenameStmt: ALTER SEQUENCE qualified_name RENAME TO name */ + case 129: #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 20012 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 130: /* RenameStmt: ALTER SEQUENCE IF_P EXISTS qualified_name RENAME TO name */ + case 130: #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 20026 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 131: /* RenameStmt: ALTER VIEW qualified_name RENAME TO name */ + case 131: #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 20040 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 132: /* RenameStmt: ALTER VIEW IF_P EXISTS qualified_name RENAME TO name */ + case 132: #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 20054 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 133: /* RenameStmt: ALTER INDEX qualified_name RENAME TO name */ + case 133: #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 20068 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 134: /* RenameStmt: ALTER INDEX IF_P EXISTS qualified_name RENAME TO name */ + case 134: #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 20082 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 135: /* RenameStmt: ALTER TABLE relation_expr RENAME opt_column name TO name */ + case 135: #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 20097 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 136: /* RenameStmt: ALTER TABLE IF_P EXISTS relation_expr RENAME opt_column name TO name */ + case 136: #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 20112 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 137: /* RenameStmt: ALTER TABLE relation_expr RENAME CONSTRAINT name TO name */ + case 137: #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 20126 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 138: /* RenameStmt: ALTER TABLE IF_P EXISTS relation_expr RENAME CONSTRAINT name TO name */ + case 138: #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 20140 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 139: /* opt_column: COLUMN */ + case 139: #line 140 "third_party/libpg_query/grammar/statements/rename.y" - { (yyval.ival) = COLUMN; } -#line 20146 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = COLUMN; ;} break; - case 140: /* opt_column: %empty */ + case 140: #line 141 "third_party/libpg_query/grammar/statements/rename.y" - { (yyval.ival) = 0; } -#line 20152 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = 0; ;} break; - case 141: /* InsertStmt: opt_with_clause INSERT opt_or_action INTO insert_target opt_by_name_or_position insert_rest opt_on_conflict returning_clause */ + case 141: #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 20166 "third_party/libpg_query/grammar/grammar_out.cpp" - break; - - case 142: /* insert_rest: SelectStmt */ + { + (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 142: #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 20176 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.istmt)->selectStmt = (yyvsp[(1) - (1)].node); + ;} break; - case 143: /* insert_rest: OVERRIDING override_kind VALUE_P SelectStmt */ + case 143: #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 20187 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.istmt)->override = (yyvsp[(2) - (4)].override); + (yyval.istmt)->selectStmt = (yyvsp[(4) - (4)].node); + ;} break; - case 144: /* insert_rest: '(' insert_column_list ')' SelectStmt */ + case 144: #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 20197 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.istmt)->cols = (yyvsp[(2) - (4)].list); + (yyval.istmt)->selectStmt = (yyvsp[(4) - (4)].node); + ;} break; - case 145: /* insert_rest: '(' insert_column_list ')' OVERRIDING override_kind VALUE_P SelectStmt */ + case 145: #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 20208 "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 146: /* insert_rest: DEFAULT VALUES */ + case 146: #line 50 "third_party/libpg_query/grammar/statements/insert.y" - { + { (yyval.istmt) = makeNode(PGInsertStmt); (yyval.istmt)->cols = NIL; (yyval.istmt)->selectStmt = NULL; - } -#line 20218 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 147: /* insert_target: qualified_name */ + case 147: #line 60 "third_party/libpg_query/grammar/statements/insert.y" - { - (yyval.range) = (yyvsp[0].range); - } -#line 20226 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.range) = (yyvsp[(1) - (1)].range); + ;} break; - case 148: /* insert_target: qualified_name AS ColId */ + case 148: #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 20235 "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 149: /* opt_by_name_or_position: BY NAME_P */ + case 149: #line 71 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.bynameorposition) = PG_INSERT_BY_NAME; } -#line 20241 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.bynameorposition) = PG_INSERT_BY_NAME; ;} break; - case 150: /* opt_by_name_or_position: BY POSITION */ + case 150: #line 72 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.bynameorposition) = PG_INSERT_BY_POSITION; } -#line 20247 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.bynameorposition) = PG_INSERT_BY_POSITION; ;} break; - case 151: /* opt_by_name_or_position: %empty */ + case 151: #line 73 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.bynameorposition) = PG_INSERT_BY_POSITION; } -#line 20253 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.bynameorposition) = PG_INSERT_BY_POSITION; ;} break; - case 152: /* opt_conf_expr: '(' index_params ')' where_clause */ + case 152: #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 20265 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.infer)->location = (yylsp[(1) - (4)]); + ;} break; - case 153: /* opt_conf_expr: ON CONSTRAINT name */ + case 153: #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 20277 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.infer)->conname = (yyvsp[(3) - (3)].str); + (yyval.infer)->location = (yylsp[(1) - (3)]); + ;} break; - case 154: /* opt_conf_expr: %empty */ + case 154: #line 95 "third_party/libpg_query/grammar/statements/insert.y" - { + { (yyval.infer) = NULL; - } -#line 20285 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 155: /* opt_with_clause: with_clause */ + case 155: #line 102 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.with) = (yyvsp[0].with); } -#line 20291 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.with) = (yyvsp[(1) - (1)].with); ;} break; - case 156: /* opt_with_clause: %empty */ + case 156: #line 103 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.with) = NULL; } -#line 20297 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.with) = NULL; ;} break; - case 157: /* insert_column_item: ColId opt_indirection */ + case 157: #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 20309 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.target)->location = (yylsp[(1) - (2)]); + ;} break; - case 158: /* set_clause: set_target '=' a_expr */ + case 158: #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 20318 "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 159: /* set_clause: '(' set_target_list ')' '=' a_expr */ + case 159: #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 20343 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.list) = (yyvsp[(2) - (5)].list); + ;} break; - case 160: /* opt_or_action: OR REPLACE */ + case 160: #line 151 "third_party/libpg_query/grammar/statements/insert.y" - { + { (yyval.onconflictshorthand) = PG_ONCONFLICT_ALIAS_REPLACE; - } -#line 20351 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 161: /* opt_or_action: OR IGNORE_P */ + case 161: #line 156 "third_party/libpg_query/grammar/statements/insert.y" - { + { (yyval.onconflictshorthand) = PG_ONCONFLICT_ALIAS_IGNORE; - } -#line 20359 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 162: /* opt_or_action: %empty */ + case 162: #line 160 "third_party/libpg_query/grammar/statements/insert.y" - { + { (yyval.onconflictshorthand) = PG_ONCONFLICT_ALIAS_NONE; - } -#line 20367 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 163: /* opt_on_conflict: ON CONFLICT opt_conf_expr DO UPDATE SET set_clause_list_opt_comma where_clause */ + case 163: #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 20380 "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 164: /* opt_on_conflict: ON CONFLICT opt_conf_expr DO NOTHING */ + case 164: #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 20393 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.onconflict)->location = (yylsp[(1) - (5)]); + ;} break; - case 165: /* opt_on_conflict: %empty */ + case 165: #line 186 "third_party/libpg_query/grammar/statements/insert.y" - { + { (yyval.onconflict) = NULL; - } -#line 20401 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 166: /* index_elem: ColId opt_collate opt_class opt_asc_desc opt_nulls_order */ + case 166: #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 20416 "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: func_expr_windowless opt_collate opt_class opt_asc_desc opt_nulls_order */ + case 167: #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 20431 "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 168: /* index_elem: '(' a_expr ')' opt_collate opt_class opt_asc_desc opt_nulls_order */ + case 168: #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 20446 "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 169: /* returning_clause: RETURNING target_list */ + case 169: #line 229 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = (yyvsp[0].list); } -#line 20452 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (2)].list); ;} break; - case 170: /* returning_clause: %empty */ + case 170: #line 230 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = NIL; } -#line 20458 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 171: /* override_kind: USER */ + case 171: #line 236 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.override) = PG_OVERRIDING_USER_VALUE; } -#line 20464 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.override) = PG_OVERRIDING_USER_VALUE; ;} break; - case 172: /* override_kind: SYSTEM_P */ + case 172: #line 237 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.override) = OVERRIDING_SYSTEM_VALUE; } -#line 20470 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.override) = OVERRIDING_SYSTEM_VALUE; ;} break; - case 173: /* set_target_list: set_target */ + case 173: #line 242 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = list_make1((yyvsp[0].target)); } -#line 20476 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].target)); ;} break; - case 174: /* set_target_list: set_target_list ',' set_target */ + case 174: #line 243 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = lappend((yyvsp[-2].list),(yyvsp[0].target)); } -#line 20482 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list),(yyvsp[(3) - (3)].target)); ;} break; - case 175: /* opt_collate: COLLATE any_name */ + case 175: #line 249 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = (yyvsp[0].list); } -#line 20488 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (2)].list); ;} break; - case 176: /* opt_collate: %empty */ + case 176: #line 250 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = NIL; } -#line 20494 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 177: /* opt_class: any_name */ + case 177: #line 254 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = (yyvsp[0].list); } -#line 20500 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 178: /* opt_class: %empty */ + case 178: #line 255 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = NIL; } -#line 20506 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 179: /* insert_column_list: insert_column_item */ + case 179: #line 261 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = list_make1((yyvsp[0].target)); } -#line 20512 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].target)); ;} break; - case 180: /* insert_column_list: insert_column_list ',' insert_column_item */ + case 180: #line 263 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].target)); } -#line 20518 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].target)); ;} break; - case 181: /* set_clause_list: set_clause */ + case 181: #line 268 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = (yyvsp[0].list); } -#line 20524 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 182: /* set_clause_list: set_clause_list ',' set_clause */ + case 182: #line 269 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = list_concat((yyvsp[-2].list),(yyvsp[0].list)); } -#line 20530 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_concat((yyvsp[(1) - (3)].list),(yyvsp[(3) - (3)].list)); ;} break; - case 183: /* set_clause_list_opt_comma: set_clause_list */ + case 183: #line 273 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = (yyvsp[0].list); } -#line 20536 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 184: /* set_clause_list_opt_comma: set_clause_list ',' */ + case 184: #line 274 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 20542 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 185: /* index_params: index_elem */ + case 185: #line 277 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = list_make1((yyvsp[0].ielem)); } -#line 20548 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].ielem)); ;} break; - case 186: /* index_params: index_params ',' index_elem */ + case 186: #line 278 "third_party/libpg_query/grammar/statements/insert.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].ielem)); } -#line 20554 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].ielem)); ;} break; - case 187: /* set_target: ColId opt_indirection */ + case 187: #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 20566 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.target)->location = (yylsp[(1) - (2)]); + ;} break; - case 188: /* CreateTypeStmt: CREATE_P TYPE_P qualified_name AS ENUM_P select_with_parens */ + case 188: #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 20579 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 189: /* CreateTypeStmt: CREATE_P TYPE_P qualified_name AS ENUM_P '(' opt_enum_val_list ')' */ + case 189: #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 20592 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 190: /* CreateTypeStmt: CREATE_P TYPE_P qualified_name AS Typename */ + case 190: #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 20611 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 191: /* opt_enum_val_list: enum_val_list */ + case 191: #line 46 "third_party/libpg_query/grammar/statements/create_type.y" - { (yyval.list) = (yyvsp[0].list);} -#line 20617 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list);;} break; - case 192: /* opt_enum_val_list: %empty */ + case 192: #line 47 "third_party/libpg_query/grammar/statements/create_type.y" - {(yyval.list) = NIL;} -#line 20623 "third_party/libpg_query/grammar/grammar_out.cpp" + {(yyval.list) = NIL;;} break; - case 193: /* enum_val_list: Sconst */ + case 193: #line 51 "third_party/libpg_query/grammar/statements/create_type.y" - { - (yyval.list) = list_make1(makeStringConst((yyvsp[0].str), (yylsp[0]))); - } -#line 20631 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = list_make1(makeStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)]))); + ;} break; - case 194: /* enum_val_list: enum_val_list ',' Sconst */ + case 194: #line 55 "third_party/libpg_query/grammar/statements/create_type.y" - { - (yyval.list) = lappend((yyvsp[-2].list), makeStringConst((yyvsp[0].str), (yylsp[0]))); - } -#line 20639 "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 195: /* PragmaStmt: PRAGMA_P ColId */ + case 195: #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 20650 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 196: /* PragmaStmt: PRAGMA_P ColId '=' var_list */ + case 196: #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 20662 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 197: /* PragmaStmt: PRAGMA_P ColId '(' func_arg_list ')' */ + case 197: #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 20674 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 198: /* CreateSeqStmt: CREATE_P OptTemp SEQUENCE qualified_name OptSeqOptList */ + case 198: #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 20688 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 199: /* CreateSeqStmt: CREATE_P OptTemp SEQUENCE IF_P NOT EXISTS qualified_name OptSeqOptList */ + case 199: #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 20702 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 200: /* CreateSeqStmt: CREATE_P OR REPLACE OptTemp SEQUENCE qualified_name OptSeqOptList */ + case 200: #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 20716 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 201: /* OptSeqOptList: SeqOptList */ + case 201: #line 42 "third_party/libpg_query/grammar/statements/create_sequence.y" - { (yyval.list) = (yyvsp[0].list); } -#line 20722 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 202: /* OptSeqOptList: %empty */ + case 202: #line 43 "third_party/libpg_query/grammar/statements/create_sequence.y" - { (yyval.list) = NIL; } -#line 20728 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 203: /* CreateSecretStmt: CREATE_P opt_persist SECRET opt_secret_name opt_storage_specifier '(' copy_generic_opt_list ')' */ + case 203: #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 20742 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 204: /* CreateSecretStmt: CREATE_P opt_persist SECRET IF_P NOT EXISTS opt_secret_name opt_storage_specifier '(' copy_generic_opt_list ')' */ + case 204: #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 20756 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 205: /* CreateSecretStmt: CREATE_P OR REPLACE opt_persist SECRET opt_secret_name opt_storage_specifier '(' copy_generic_opt_list ')' */ + case 205: #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 20770 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 206: /* opt_secret_name: %empty */ + case 206: #line 40 "third_party/libpg_query/grammar/statements/create_secret.y" - { (yyval.str) = NULL; } -#line 20776 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = NULL; ;} break; - case 207: /* opt_secret_name: ColId */ + case 207: #line 41 "third_party/libpg_query/grammar/statements/create_secret.y" - { (yyval.str) = (yyvsp[0].str); } -#line 20782 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 208: /* opt_persist: %empty */ + case 208: #line 45 "third_party/libpg_query/grammar/statements/create_secret.y" - { (yyval.str) = pstrdup("default"); } -#line 20788 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = pstrdup("default"); ;} break; - case 209: /* opt_persist: TEMPORARY */ + case 209: #line 46 "third_party/libpg_query/grammar/statements/create_secret.y" - { (yyval.str) = pstrdup("temporary"); } -#line 20794 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = pstrdup("temporary"); ;} break; - case 210: /* opt_persist: PERSISTENT */ + case 210: #line 47 "third_party/libpg_query/grammar/statements/create_secret.y" - { (yyval.str) = pstrdup("persistent"); } -#line 20800 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = pstrdup("persistent"); ;} break; - case 211: /* opt_storage_specifier: %empty */ + case 211: #line 51 "third_party/libpg_query/grammar/statements/create_secret.y" - { (yyval.str) = pstrdup(""); } -#line 20806 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = pstrdup(""); ;} break; - case 212: /* opt_storage_specifier: IN_P IDENT */ + case 212: #line 52 "third_party/libpg_query/grammar/statements/create_secret.y" - { (yyval.str) = (yyvsp[0].str); } -#line 20812 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(2) - (2)].str); ;} break; - case 213: /* UpdateExtensionsStmt: opt_with_clause UPDATE EXTENSIONS opt_column_list */ + case 213: #line 8 "third_party/libpg_query/grammar/statements/update_extensions.y" - { + { PGUpdateExtensionsStmt *n = makeNode(PGUpdateExtensionsStmt); - n->extensions = (yyvsp[0].list); + n->extensions = (yyvsp[(4) - (4)].list); - if ((yyvsp[-3].with)) { + if ((yyvsp[(1) - (4)].with)) { ereport(ERROR, (errcode(PG_ERRCODE_SYNTAX_ERROR), errmsg("Providing a with clause with an UPDATE EXTENSIONS statement is not allowed"), - parser_errposition((yylsp[-3])))); + parser_errposition((yylsp[(1) - (4)])))); break; } (yyval.node) = (PGNode *)n; - } -#line 20831 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 214: /* ExecuteStmt: EXECUTE name execute_param_clause */ + case 214: #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 20842 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 215: /* ExecuteStmt: CREATE_P OptTemp TABLE create_as_target AS EXECUTE name execute_param_clause opt_with_data */ + case 215: #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 20862 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 216: /* ExecuteStmt: CREATE_P OptTemp TABLE IF_P NOT EXISTS create_as_target AS EXECUTE name execute_param_clause opt_with_data */ + case 216: #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 20882 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 217: /* execute_param_expr: a_expr */ + case 217: #line 52 "third_party/libpg_query/grammar/statements/execute.y" - { - (yyval.node) = (yyvsp[0].node); - } -#line 20890 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (yyvsp[(1) - (1)].node); + ;} break; - case 218: /* execute_param_expr: param_name COLON_EQUALS a_expr */ + case 218: #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 20903 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 219: /* execute_param_list: execute_param_expr */ + case 219: #line 66 "third_party/libpg_query/grammar/statements/execute.y" - { - (yyval.list) = list_make1((yyvsp[0].node)); - } -#line 20911 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); + ;} break; - case 220: /* execute_param_list: execute_param_list ',' execute_param_expr */ + case 220: #line 70 "third_party/libpg_query/grammar/statements/execute.y" - { - (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].node)); - } -#line 20919 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); + ;} break; - case 221: /* execute_param_clause: '(' execute_param_list ')' */ + case 221: #line 75 "third_party/libpg_query/grammar/statements/execute.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 20925 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 222: /* execute_param_clause: %empty */ + case 222: #line 76 "third_party/libpg_query/grammar/statements/execute.y" - { (yyval.list) = NIL; } -#line 20931 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 223: /* AlterSeqStmt: ALTER SEQUENCE qualified_name SeqOptList */ + case 223: #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 20943 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 224: /* AlterSeqStmt: ALTER SEQUENCE IF_P EXISTS qualified_name SeqOptList */ + case 224: #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 20955 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 225: /* SeqOptList: SeqOptElem */ + case 225: #line 29 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { (yyval.list) = list_make1((yyvsp[0].defelt)); } -#line 20961 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); ;} break; - case 226: /* SeqOptList: SeqOptList SeqOptElem */ + case 226: #line 30 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { (yyval.list) = lappend((yyvsp[-1].list), (yyvsp[0].defelt)); } -#line 20967 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].defelt)); ;} break; - case 227: /* opt_with: WITH */ + case 227: #line 34 "third_party/libpg_query/grammar/statements/alter_sequence.y" - {} -#line 20973 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 228: /* opt_with: WITH_LA */ + case 228: #line 35 "third_party/libpg_query/grammar/statements/alter_sequence.y" - {} -#line 20979 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 229: /* opt_with: %empty */ + case 229: #line 36 "third_party/libpg_query/grammar/statements/alter_sequence.y" - {} -#line 20985 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 230: /* NumericOnly: FCONST */ + case 230: #line 41 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { (yyval.value) = makeFloat((yyvsp[0].str)); } -#line 20991 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.value) = makeFloat((yyvsp[(1) - (1)].str)); ;} break; - case 231: /* NumericOnly: '+' FCONST */ + case 231: #line 42 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { (yyval.value) = makeFloat((yyvsp[0].str)); } -#line 20997 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.value) = makeFloat((yyvsp[(2) - (2)].str)); ;} break; - case 232: /* NumericOnly: '-' FCONST */ + case 232: #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 21006 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 233: /* NumericOnly: SignedIconst */ + case 233: #line 48 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { (yyval.value) = makeInteger((yyvsp[0].ival)); } -#line 21012 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.value) = makeInteger((yyvsp[(1) - (1)].ival)); ;} break; - case 234: /* SeqOptElem: AS SimpleTypename */ + case 234: #line 53 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { - (yyval.defelt) = makeDefElem("as", (PGNode *)(yyvsp[0].typnam), (yylsp[-1])); - } -#line 21020 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("as", (PGNode *)(yyvsp[(2) - (2)].typnam), (yylsp[(1) - (2)])); + ;} break; - case 235: /* SeqOptElem: CACHE NumericOnly */ + case 235: #line 57 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { - (yyval.defelt) = makeDefElem("cache", (PGNode *)(yyvsp[0].value), (yylsp[-1])); - } -#line 21028 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("cache", (PGNode *)(yyvsp[(2) - (2)].value), (yylsp[(1) - (2)])); + ;} break; - case 236: /* SeqOptElem: CYCLE */ + case 236: #line 61 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { - (yyval.defelt) = makeDefElem("cycle", (PGNode *)makeInteger(true), (yylsp[0])); - } -#line 21036 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("cycle", (PGNode *)makeInteger(true), (yylsp[(1) - (1)])); + ;} break; - case 237: /* SeqOptElem: NO CYCLE */ + case 237: #line 65 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { - (yyval.defelt) = makeDefElem("cycle", (PGNode *)makeInteger(false), (yylsp[-1])); - } -#line 21044 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("cycle", (PGNode *)makeInteger(false), (yylsp[(1) - (2)])); + ;} break; - case 238: /* SeqOptElem: INCREMENT opt_by NumericOnly */ + case 238: #line 69 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { - (yyval.defelt) = makeDefElem("increment", (PGNode *)(yyvsp[0].value), (yylsp[-2])); - } -#line 21052 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("increment", (PGNode *)(yyvsp[(3) - (3)].value), (yylsp[(1) - (3)])); + ;} break; - case 239: /* SeqOptElem: MAXVALUE NumericOnly */ + case 239: #line 73 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { - (yyval.defelt) = makeDefElem("maxvalue", (PGNode *)(yyvsp[0].value), (yylsp[-1])); - } -#line 21060 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("maxvalue", (PGNode *)(yyvsp[(2) - (2)].value), (yylsp[(1) - (2)])); + ;} break; - case 240: /* SeqOptElem: MINVALUE NumericOnly */ + case 240: #line 77 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { - (yyval.defelt) = makeDefElem("minvalue", (PGNode *)(yyvsp[0].value), (yylsp[-1])); - } -#line 21068 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("minvalue", (PGNode *)(yyvsp[(2) - (2)].value), (yylsp[(1) - (2)])); + ;} break; - case 241: /* SeqOptElem: NO MAXVALUE */ + case 241: #line 81 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { - (yyval.defelt) = makeDefElem("maxvalue", NULL, (yylsp[-1])); - } -#line 21076 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("maxvalue", NULL, (yylsp[(1) - (2)])); + ;} break; - case 242: /* SeqOptElem: NO MINVALUE */ + case 242: #line 85 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { - (yyval.defelt) = makeDefElem("minvalue", NULL, (yylsp[-1])); - } -#line 21084 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("minvalue", NULL, (yylsp[(1) - (2)])); + ;} break; - case 243: /* SeqOptElem: OWNED BY any_name */ + case 243: #line 89 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { - (yyval.defelt) = makeDefElem("owned_by", (PGNode *)(yyvsp[0].list), (yylsp[-2])); - } -#line 21092 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("owned_by", (PGNode *)(yyvsp[(3) - (3)].list), (yylsp[(1) - (3)])); + ;} break; - case 244: /* SeqOptElem: SEQUENCE NAME_P any_name */ + case 244: #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 21101 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.defelt) = makeDefElem("sequence_name", (PGNode *)(yyvsp[(3) - (3)].list), (yylsp[(1) - (3)])); + ;} break; - case 245: /* SeqOptElem: START opt_with NumericOnly */ + case 245: #line 98 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { - (yyval.defelt) = makeDefElem("start", (PGNode *)(yyvsp[0].value), (yylsp[-2])); - } -#line 21109 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("start", (PGNode *)(yyvsp[(3) - (3)].value), (yylsp[(1) - (3)])); + ;} break; - case 246: /* SeqOptElem: RESTART */ + case 246: #line 102 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { - (yyval.defelt) = makeDefElem("restart", NULL, (yylsp[0])); - } -#line 21117 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("restart", NULL, (yylsp[(1) - (1)])); + ;} break; - case 247: /* SeqOptElem: RESTART opt_with NumericOnly */ + case 247: #line 106 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { - (yyval.defelt) = makeDefElem("restart", (PGNode *)(yyvsp[0].value), (yylsp[-2])); - } -#line 21125 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("restart", (PGNode *)(yyvsp[(3) - (3)].value), (yylsp[(1) - (3)])); + ;} break; - case 248: /* opt_by: BY */ + case 248: #line 112 "third_party/libpg_query/grammar/statements/alter_sequence.y" - {} -#line 21131 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 249: /* opt_by: %empty */ + case 249: #line 113 "third_party/libpg_query/grammar/statements/alter_sequence.y" - {} -#line 21137 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 250: /* SignedIconst: Iconst */ + case 250: #line 117 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { (yyval.ival) = (yyvsp[0].ival); } -#line 21143 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = (yyvsp[(1) - (1)].ival); ;} break; - case 251: /* SignedIconst: '+' Iconst */ + case 251: #line 118 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { (yyval.ival) = + (yyvsp[0].ival); } -#line 21149 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = + (yyvsp[(2) - (2)].ival); ;} break; - case 252: /* SignedIconst: '-' Iconst */ + case 252: #line 119 "third_party/libpg_query/grammar/statements/alter_sequence.y" - { (yyval.ival) = - (yyvsp[0].ival); } -#line 21155 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = - (yyvsp[(2) - (2)].ival); ;} break; - case 253: /* DropSecretStmt: DROP opt_persist SECRET ColId opt_storage_drop_specifier */ + case 253: #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 21168 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 254: /* DropSecretStmt: DROP opt_persist SECRET IF_P EXISTS ColId opt_storage_drop_specifier */ + case 254: #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 21181 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 255: /* opt_storage_drop_specifier: %empty */ + case 255: #line 28 "third_party/libpg_query/grammar/statements/drop_secret.y" - { (yyval.str) = pstrdup(""); } -#line 21187 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = pstrdup(""); ;} break; - case 256: /* opt_storage_drop_specifier: FROM IDENT */ + case 256: #line 29 "third_party/libpg_query/grammar/statements/drop_secret.y" - { (yyval.str) = (yyvsp[0].str); } -#line 21193 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(2) - (2)].str); ;} break; - case 257: /* TransactionStmt: ABORT_P opt_transaction */ + case 257: #line 3 "third_party/libpg_query/grammar/statements/transaction.y" - { + { PGTransactionStmt *n = makeNode(PGTransactionStmt); n->kind = PG_TRANS_STMT_ROLLBACK; n->options = NIL; + n->transaction_type = PG_TRANS_TYPE_DEFAULT; (yyval.node) = (PGNode *)n; - } -#line 21204 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 258: /* TransactionStmt: BEGIN_P opt_transaction */ -#line 10 "third_party/libpg_query/grammar/statements/transaction.y" - { + case 258: +#line 11 "third_party/libpg_query/grammar/statements/transaction.y" + { PGTransactionStmt *n = makeNode(PGTransactionStmt); n->kind = PG_TRANS_STMT_BEGIN; + n->transaction_type = (yyvsp[(3) - (3)].transactiontype); (yyval.node) = (PGNode *)n; - } -#line 21214 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 259: /* TransactionStmt: START opt_transaction */ -#line 16 "third_party/libpg_query/grammar/statements/transaction.y" - { + case 259: +#line 18 "third_party/libpg_query/grammar/statements/transaction.y" + { PGTransactionStmt *n = makeNode(PGTransactionStmt); n->kind = PG_TRANS_STMT_START; + n->transaction_type = (yyvsp[(3) - (3)].transactiontype); (yyval.node) = (PGNode *)n; - } -#line 21224 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 260: /* TransactionStmt: COMMIT opt_transaction */ -#line 22 "third_party/libpg_query/grammar/statements/transaction.y" - { + case 260: +#line 25 "third_party/libpg_query/grammar/statements/transaction.y" + { PGTransactionStmt *n = makeNode(PGTransactionStmt); n->kind = PG_TRANS_STMT_COMMIT; n->options = NIL; + n->transaction_type = PG_TRANS_TYPE_DEFAULT; (yyval.node) = (PGNode *)n; - } -#line 21235 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 261: /* TransactionStmt: END_P opt_transaction */ -#line 29 "third_party/libpg_query/grammar/statements/transaction.y" - { + case 261: +#line 33 "third_party/libpg_query/grammar/statements/transaction.y" + { PGTransactionStmt *n = makeNode(PGTransactionStmt); n->kind = PG_TRANS_STMT_COMMIT; n->options = NIL; + n->transaction_type = PG_TRANS_TYPE_DEFAULT; (yyval.node) = (PGNode *)n; - } -#line 21246 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 262: /* TransactionStmt: ROLLBACK opt_transaction */ -#line 36 "third_party/libpg_query/grammar/statements/transaction.y" - { + case 262: +#line 41 "third_party/libpg_query/grammar/statements/transaction.y" + { PGTransactionStmt *n = makeNode(PGTransactionStmt); n->kind = PG_TRANS_STMT_ROLLBACK; n->options = NIL; + n->transaction_type = PG_TRANS_TYPE_DEFAULT; (yyval.node) = (PGNode *)n; - } -#line 21257 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} + break; + + case 263: +#line 51 "third_party/libpg_query/grammar/statements/transaction.y" + {;} + break; + + case 264: +#line 52 "third_party/libpg_query/grammar/statements/transaction.y" + {;} + break; + + case 265: +#line 53 "third_party/libpg_query/grammar/statements/transaction.y" + {;} break; - case 263: /* opt_transaction: WORK */ -#line 45 "third_party/libpg_query/grammar/statements/transaction.y" - {} -#line 21263 "third_party/libpg_query/grammar/grammar_out.cpp" + case 266: +#line 57 "third_party/libpg_query/grammar/statements/transaction.y" + { (yyval.transactiontype) = PG_TRANS_TYPE_READ_ONLY; ;} break; - case 264: /* opt_transaction: TRANSACTION */ -#line 46 "third_party/libpg_query/grammar/statements/transaction.y" - {} -#line 21269 "third_party/libpg_query/grammar/grammar_out.cpp" + case 267: +#line 58 "third_party/libpg_query/grammar/statements/transaction.y" + { (yyval.transactiontype) = PG_TRANS_TYPE_READ_WRITE; ;} break; - case 265: /* opt_transaction: %empty */ -#line 47 "third_party/libpg_query/grammar/statements/transaction.y" - {} -#line 21275 "third_party/libpg_query/grammar/grammar_out.cpp" + case 268: +#line 59 "third_party/libpg_query/grammar/statements/transaction.y" + { (yyval.transactiontype) = PG_TRANS_TYPE_DEFAULT; ;} break; - case 266: /* UseStmt: USE_P qualified_name */ + case 269: #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 21285 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 267: /* CreateStmt: CREATE_P OptTemp TABLE qualified_name '(' OptTableElementList ')' OptWith OnCommitOption */ + case 270: #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 21302 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 268: /* CreateStmt: CREATE_P OptTemp TABLE IF_P NOT EXISTS qualified_name '(' OptTableElementList ')' OptWith OnCommitOption */ + case 271: #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 21319 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 269: /* CreateStmt: CREATE_P OR REPLACE OptTemp TABLE qualified_name '(' OptTableElementList ')' OptWith OnCommitOption */ + case 272: #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 21336 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 270: /* ConstraintAttributeSpec: %empty */ + case 273: #line 56 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = 0; } -#line 21342 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = 0; ;} break; - case 271: /* ConstraintAttributeSpec: ConstraintAttributeSpec ConstraintAttributeElem */ + case 274: #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 21370 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 272: /* def_arg: func_type */ + case 275: #line 84 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.node) = (PGNode *)(yyvsp[0].typnam); } -#line 21376 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *)(yyvsp[(1) - (1)].typnam); ;} break; - case 273: /* def_arg: reserved_keyword */ + case 276: #line 85 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.node) = (PGNode *)makeString(pstrdup((yyvsp[0].keyword))); } -#line 21382 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *)makeString(pstrdup((yyvsp[(1) - (1)].keyword))); ;} break; - case 274: /* def_arg: qual_all_Op */ + case 277: #line 86 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.node) = (PGNode *)(yyvsp[0].list); } -#line 21388 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *)(yyvsp[(1) - (1)].list); ;} break; - case 275: /* def_arg: NumericOnly */ + case 278: #line 87 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.node) = (PGNode *)(yyvsp[0].value); } -#line 21394 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *)(yyvsp[(1) - (1)].value); ;} break; - case 276: /* def_arg: Sconst */ + case 279: #line 88 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.node) = (PGNode *)makeString((yyvsp[0].str)); } -#line 21400 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *)makeString((yyvsp[(1) - (1)].str)); ;} break; - case 277: /* def_arg: NONE */ + case 280: #line 89 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.node) = (PGNode *)makeString(pstrdup((yyvsp[0].keyword))); } -#line 21406 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *)makeString(pstrdup((yyvsp[(1) - (1)].keyword))); ;} break; - case 278: /* OptParenthesizedSeqOptList: '(' SeqOptList ')' */ + case 281: #line 93 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 21412 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 279: /* OptParenthesizedSeqOptList: %empty */ + case 282: #line 94 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = NIL; } -#line 21418 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 280: /* generic_option_arg: Sconst */ + case 283: #line 99 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.node) = (PGNode *) makeString((yyvsp[0].str)); } -#line 21424 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeString((yyvsp[(1) - (1)].str)); ;} break; - case 281: /* key_action: NO ACTION */ + case 284: #line 104 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_FKCONSTR_ACTION_NOACTION; } -#line 21430 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_FKCONSTR_ACTION_NOACTION; ;} break; - case 282: /* key_action: RESTRICT */ + case 285: #line 105 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_FKCONSTR_ACTION_RESTRICT; } -#line 21436 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_FKCONSTR_ACTION_RESTRICT; ;} break; - case 283: /* key_action: CASCADE */ + case 286: #line 106 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_FKCONSTR_ACTION_CASCADE; } -#line 21442 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_FKCONSTR_ACTION_CASCADE; ;} break; - case 284: /* key_action: SET NULL_P */ + case 287: #line 107 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_FKCONSTR_ACTION_SETNULL; } -#line 21448 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_FKCONSTR_ACTION_SETNULL; ;} break; - case 285: /* key_action: SET DEFAULT */ + case 288: #line 108 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_FKCONSTR_ACTION_SETDEFAULT; } -#line 21454 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_FKCONSTR_ACTION_SETDEFAULT; ;} break; - case 286: /* ColConstraint: CONSTRAINT name ColConstraintElem */ + case 289: #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 21465 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 287: /* ColConstraint: ColConstraintElem */ + case 290: #line 120 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.node) = (yyvsp[0].node); } -#line 21471 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 288: /* ColConstraint: ConstraintAttr */ + case 291: #line 121 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.node) = (yyvsp[0].node); } -#line 21477 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 289: /* ColConstraint: COLLATE any_name */ + case 292: #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 @@ -21486,169 +22303,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 21494 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 290: /* ColConstraintElem: NOT NULL_P */ + case 293: #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 21505 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 291: /* ColConstraintElem: NULL_P */ + case 294: #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 21516 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 292: /* ColConstraintElem: UNIQUE opt_definition */ + case 295: #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 21530 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 293: /* ColConstraintElem: PRIMARY KEY opt_definition */ + case 296: #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 21544 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 294: /* ColConstraintElem: CHECK_P '(' a_expr ')' opt_no_inherit */ + case 297: #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 21560 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 295: /* ColConstraintElem: USING COMPRESSION name */ + case 298: #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 21572 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 296: /* ColConstraintElem: DEFAULT b_expr */ + case 299: #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 21585 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 297: /* ColConstraintElem: REFERENCES qualified_name opt_column_list key_match key_actions */ + case 300: #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 21604 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 298: /* GeneratedColumnType: VIRTUAL */ + case 301: #line 220 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.constr) = PG_CONSTR_GENERATED_VIRTUAL; } -#line 21610 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.constr) = PG_CONSTR_GENERATED_VIRTUAL; ;} break; - case 299: /* GeneratedColumnType: STORED */ + case 302: #line 221 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.constr) = PG_CONSTR_GENERATED_STORED; } -#line 21616 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.constr) = PG_CONSTR_GENERATED_STORED; ;} break; - case 300: /* opt_GeneratedColumnType: GeneratedColumnType */ + case 303: #line 225 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.constr) = (yyvsp[0].constr); } -#line 21622 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.constr) = (yyvsp[(1) - (1)].constr); ;} break; - case 301: /* opt_GeneratedColumnType: %empty */ + case 304: #line 226 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.constr) = PG_CONSTR_GENERATED_VIRTUAL; } -#line 21628 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.constr) = PG_CONSTR_GENERATED_VIRTUAL; ;} break; - case 302: /* GeneratedConstraintElem: GENERATED generated_when AS IDENTITY_P OptParenthesizedSeqOptList */ + case 305: #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 21641 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 303: /* GeneratedConstraintElem: GENERATED generated_when AS '(' a_expr ')' opt_GeneratedColumnType */ + case 306: #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 @@ -21656,341 +22459,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 21668 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 304: /* GeneratedConstraintElem: AS '(' a_expr ')' opt_GeneratedColumnType */ + case 307: #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 21682 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 305: /* generic_option_elem: generic_option_name generic_option_arg */ + case 308: #line 277 "third_party/libpg_query/grammar/statements/create.y" - { - (yyval.defelt) = makeDefElem((yyvsp[-1].str), (yyvsp[0].node), (yylsp[-1])); - } -#line 21690 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); + ;} break; - case 306: /* key_update: ON UPDATE key_action */ + case 309: #line 283 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = (yyvsp[0].ival); } -#line 21696 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = (yyvsp[(3) - (3)].ival); ;} break; - case 307: /* key_actions: key_update */ + case 310: #line 289 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = ((yyvsp[0].ival) << 8) | (PG_FKCONSTR_ACTION_NOACTION & 0xFF); } -#line 21702 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = ((yyvsp[(1) - (1)].ival) << 8) | (PG_FKCONSTR_ACTION_NOACTION & 0xFF); ;} break; - case 308: /* key_actions: key_delete */ + case 311: #line 291 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = (PG_FKCONSTR_ACTION_NOACTION << 8) | ((yyvsp[0].ival) & 0xFF); } -#line 21708 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = (PG_FKCONSTR_ACTION_NOACTION << 8) | ((yyvsp[(1) - (1)].ival) & 0xFF); ;} break; - case 309: /* key_actions: key_update key_delete */ + case 312: #line 293 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = ((yyvsp[-1].ival) << 8) | ((yyvsp[0].ival) & 0xFF); } -#line 21714 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = ((yyvsp[(1) - (2)].ival) << 8) | ((yyvsp[(2) - (2)].ival) & 0xFF); ;} break; - case 310: /* key_actions: key_delete key_update */ + case 313: #line 295 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = ((yyvsp[0].ival) << 8) | ((yyvsp[-1].ival) & 0xFF); } -#line 21720 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = ((yyvsp[(2) - (2)].ival) << 8) | ((yyvsp[(1) - (2)].ival) & 0xFF); ;} break; - case 311: /* key_actions: %empty */ + case 314: #line 297 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = (PG_FKCONSTR_ACTION_NOACTION << 8) | (PG_FKCONSTR_ACTION_NOACTION & 0xFF); } -#line 21726 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = (PG_FKCONSTR_ACTION_NOACTION << 8) | (PG_FKCONSTR_ACTION_NOACTION & 0xFF); ;} break; - case 312: /* OnCommitOption: ON COMMIT DROP */ + case 315: #line 300 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.oncommit) = ONCOMMIT_DROP; } -#line 21732 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.oncommit) = ONCOMMIT_DROP; ;} break; - case 313: /* OnCommitOption: ON COMMIT DELETE_P ROWS */ + case 316: #line 301 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.oncommit) = PG_ONCOMMIT_DELETE_ROWS; } -#line 21738 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.oncommit) = PG_ONCOMMIT_DELETE_ROWS; ;} break; - case 314: /* OnCommitOption: ON COMMIT PRESERVE ROWS */ + case 317: #line 302 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.oncommit) = PG_ONCOMMIT_PRESERVE_ROWS; } -#line 21744 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.oncommit) = PG_ONCOMMIT_PRESERVE_ROWS; ;} break; - case 315: /* OnCommitOption: %empty */ + case 318: #line 303 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.oncommit) = PG_ONCOMMIT_NOOP; } -#line 21750 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.oncommit) = PG_ONCOMMIT_NOOP; ;} break; - case 316: /* reloptions: '(' reloption_list ')' */ + case 319: #line 308 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 21756 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 317: /* opt_no_inherit: NO INHERIT */ + case 320: #line 312 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.boolean) = true; } -#line 21762 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = true; ;} break; - case 318: /* opt_no_inherit: %empty */ + case 321: #line 313 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.boolean) = false; } -#line 21768 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = false; ;} break; - case 319: /* TableConstraint: CONSTRAINT name ConstraintElem */ + case 322: #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 21779 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 320: /* TableConstraint: ConstraintElem */ + case 323: #line 325 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.node) = (yyvsp[0].node); } -#line 21785 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 321: /* TableLikeOption: COMMENTS */ + case 324: #line 330 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_CREATE_TABLE_LIKE_COMMENTS; } -#line 21791 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_CREATE_TABLE_LIKE_COMMENTS; ;} break; - case 322: /* TableLikeOption: CONSTRAINTS */ + case 325: #line 331 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_CREATE_TABLE_LIKE_CONSTRAINTS; } -#line 21797 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_CREATE_TABLE_LIKE_CONSTRAINTS; ;} break; - case 323: /* TableLikeOption: DEFAULTS */ + case 326: #line 332 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_CREATE_TABLE_LIKE_DEFAULTS; } -#line 21803 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_CREATE_TABLE_LIKE_DEFAULTS; ;} break; - case 324: /* TableLikeOption: IDENTITY_P */ + case 327: #line 333 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_CREATE_TABLE_LIKE_IDENTITY; } -#line 21809 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_CREATE_TABLE_LIKE_IDENTITY; ;} break; - case 325: /* TableLikeOption: INDEXES */ + case 328: #line 334 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_CREATE_TABLE_LIKE_INDEXES; } -#line 21815 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_CREATE_TABLE_LIKE_INDEXES; ;} break; - case 326: /* TableLikeOption: STATISTICS */ + case 329: #line 335 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_CREATE_TABLE_LIKE_STATISTICS; } -#line 21821 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_CREATE_TABLE_LIKE_STATISTICS; ;} break; - case 327: /* TableLikeOption: STORAGE */ + case 330: #line 336 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_CREATE_TABLE_LIKE_STORAGE; } -#line 21827 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_CREATE_TABLE_LIKE_STORAGE; ;} break; - case 328: /* TableLikeOption: ALL */ + case 331: #line 337 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_CREATE_TABLE_LIKE_ALL; } -#line 21833 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_CREATE_TABLE_LIKE_ALL; ;} break; - case 329: /* reloption_list: reloption_elem */ + case 332: #line 343 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = list_make1((yyvsp[0].defelt)); } -#line 21839 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); ;} break; - case 330: /* reloption_list: reloption_list ',' reloption_elem */ + case 333: #line 344 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].defelt)); } -#line 21845 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt)); ;} break; - case 331: /* ExistingIndex: USING INDEX index_name */ + case 334: #line 348 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.str) = (yyvsp[0].str); } -#line 21851 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(3) - (3)].str); ;} break; - case 332: /* ConstraintAttr: DEFERRABLE */ + case 335: #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 21862 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 333: /* ConstraintAttr: NOT DEFERRABLE */ + case 336: #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 21873 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 334: /* ConstraintAttr: INITIALLY DEFERRED */ + case 337: #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 21884 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 335: /* ConstraintAttr: INITIALLY IMMEDIATE */ + case 338: #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 21895 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 336: /* OptWith: WITH reloptions */ + case 339: #line 386 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = (yyvsp[0].list); } -#line 21901 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (2)].list); ;} break; - case 337: /* OptWith: WITH OIDS */ + case 340: #line 387 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = list_make1(makeDefElem("oids", (PGNode *) makeInteger(true), (yylsp[-1]))); } -#line 21907 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeDefElem("oids", (PGNode *) makeInteger(true), (yylsp[(1) - (2)]))); ;} break; - case 338: /* OptWith: WITHOUT OIDS */ + case 341: #line 388 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = list_make1(makeDefElem("oids", (PGNode *) makeInteger(false), (yylsp[-1]))); } -#line 21913 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeDefElem("oids", (PGNode *) makeInteger(false), (yylsp[(1) - (2)]))); ;} break; - case 339: /* OptWith: %empty */ + case 342: #line 389 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = NIL; } -#line 21919 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 340: /* definition: '(' def_list ')' */ + case 343: #line 393 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 21925 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 341: /* TableLikeOptionList: TableLikeOptionList INCLUDING TableLikeOption */ + case 344: #line 398 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = (yyvsp[-2].ival) | (yyvsp[0].ival); } -#line 21931 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = (yyvsp[(1) - (3)].ival) | (yyvsp[(3) - (3)].ival); ;} break; - case 342: /* TableLikeOptionList: TableLikeOptionList EXCLUDING TableLikeOption */ + case 345: #line 399 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = (yyvsp[-2].ival) & ~(yyvsp[0].ival); } -#line 21937 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = (yyvsp[(1) - (3)].ival) & ~(yyvsp[(3) - (3)].ival); ;} break; - case 343: /* TableLikeOptionList: %empty */ + case 346: #line 400 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = 0; } -#line 21943 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = 0; ;} break; - case 344: /* generic_option_name: ColLabel */ + case 347: #line 405 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.str) = (yyvsp[0].str); } -#line 21949 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 345: /* ConstraintAttributeElem: NOT DEFERRABLE */ + case 348: #line 410 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = CAS_NOT_DEFERRABLE; } -#line 21955 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = CAS_NOT_DEFERRABLE; ;} break; - case 346: /* ConstraintAttributeElem: DEFERRABLE */ + case 349: #line 411 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = CAS_DEFERRABLE; } -#line 21961 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = CAS_DEFERRABLE; ;} break; - case 347: /* ConstraintAttributeElem: INITIALLY IMMEDIATE */ + case 350: #line 412 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = CAS_INITIALLY_IMMEDIATE; } -#line 21967 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = CAS_INITIALLY_IMMEDIATE; ;} break; - case 348: /* ConstraintAttributeElem: INITIALLY DEFERRED */ + case 351: #line 413 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = CAS_INITIALLY_DEFERRED; } -#line 21973 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = CAS_INITIALLY_DEFERRED; ;} break; - case 349: /* ConstraintAttributeElem: NOT VALID */ + case 352: #line 414 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = CAS_NOT_VALID; } -#line 21979 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = CAS_NOT_VALID; ;} break; - case 350: /* ConstraintAttributeElem: NO INHERIT */ + case 353: #line 415 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = CAS_NO_INHERIT; } -#line 21985 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = CAS_NO_INHERIT; ;} break; - case 351: /* columnDef: ColId Typename ColQualList */ + case 354: #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; @@ -21999,21 +22754,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 22008 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 352: /* columnDef: ColId opt_Typename GeneratedConstraintElem ColQualList */ + case 355: #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; @@ -22023,1531 +22777,1352 @@ 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 22038 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 353: /* def_list: def_elem */ + case 356: #line 469 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = list_make1((yyvsp[0].defelt)); } -#line 22044 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); ;} break; - case 354: /* def_list: def_list ',' def_elem */ + case 357: #line 470 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].defelt)); } -#line 22050 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt)); ;} break; - case 355: /* index_name: ColId */ + case 358: #line 474 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.str) = (yyvsp[0].str); } -#line 22056 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 356: /* TableElement: columnDef */ + case 359: #line 478 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.node) = (yyvsp[0].node); } -#line 22062 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 357: /* TableElement: TableLikeClause */ + case 360: #line 479 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.node) = (yyvsp[0].node); } -#line 22068 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 358: /* TableElement: TableConstraint */ + case 361: #line 480 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.node) = (yyvsp[0].node); } -#line 22074 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 359: /* def_elem: ColLabel '=' def_arg */ + case 362: #line 485 "third_party/libpg_query/grammar/statements/create.y" - { - (yyval.defelt) = makeDefElem((yyvsp[-2].str), (PGNode *) (yyvsp[0].node), (yylsp[-2])); - } -#line 22082 "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 360: /* def_elem: ColLabel */ + case 363: #line 489 "third_party/libpg_query/grammar/statements/create.y" - { - (yyval.defelt) = makeDefElem((yyvsp[0].str), NULL, (yylsp[0])); - } -#line 22090 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem((yyvsp[(1) - (1)].str), NULL, (yylsp[(1) - (1)])); + ;} break; - case 361: /* opt_definition: WITH definition */ + case 364: #line 496 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = (yyvsp[0].list); } -#line 22096 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (2)].list); ;} break; - case 362: /* opt_definition: %empty */ + case 365: #line 497 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = NIL; } -#line 22102 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 363: /* OptTableElementList: TableElementList */ + case 366: #line 502 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = (yyvsp[0].list); } -#line 22108 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 364: /* OptTableElementList: TableElementList ',' */ + case 367: #line 503 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 22114 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 365: /* OptTableElementList: %empty */ + case 368: #line 504 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = NIL; } -#line 22120 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 366: /* columnElem: ColId */ + case 369: #line 509 "third_party/libpg_query/grammar/statements/create.y" - { - (yyval.node) = (PGNode *) makeString((yyvsp[0].str)); - } -#line 22128 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (PGNode *) makeString((yyvsp[(1) - (1)].str)); + ;} break; - case 367: /* opt_column_list: '(' columnList ')' */ + case 370: #line 516 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 22134 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 368: /* opt_column_list: %empty */ + case 371: #line 517 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = NIL; } -#line 22140 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 369: /* ColQualList: ColQualList ColConstraint */ + case 372: #line 522 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = lappend((yyvsp[-1].list), (yyvsp[0].node)); } -#line 22146 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;} break; - case 370: /* ColQualList: %empty */ + case 373: #line 523 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = NIL; } -#line 22152 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 371: /* key_delete: ON DELETE_P key_action */ + case 374: #line 527 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = (yyvsp[0].ival); } -#line 22158 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = (yyvsp[(3) - (3)].ival); ;} break; - case 372: /* reloption_elem: ColLabel '=' def_arg */ + case 375: #line 533 "third_party/libpg_query/grammar/statements/create.y" - { - (yyval.defelt) = makeDefElem((yyvsp[-2].str), (PGNode *) (yyvsp[0].node), (yylsp[-2])); - } -#line 22166 "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 373: /* reloption_elem: ColLabel */ + case 376: #line 537 "third_party/libpg_query/grammar/statements/create.y" - { - (yyval.defelt) = makeDefElem((yyvsp[0].str), NULL, (yylsp[0])); - } -#line 22174 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem((yyvsp[(1) - (1)].str), NULL, (yylsp[(1) - (1)])); + ;} break; - case 374: /* reloption_elem: ColLabel '.' ColLabel '=' def_arg */ + case 377: #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 22183 "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 375: /* reloption_elem: ColLabel '.' ColLabel */ + case 378: #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 22191 "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 376: /* columnList: columnElem */ + case 379: #line 553 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = list_make1((yyvsp[0].node)); } -#line 22197 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 377: /* columnList: columnList ',' columnElem */ + case 380: #line 554 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].node)); } -#line 22203 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; - case 378: /* columnList_opt_comma: columnList */ + case 381: #line 558 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = (yyvsp[0].list); } -#line 22209 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 379: /* columnList_opt_comma: columnList ',' */ + case 382: #line 559 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 22215 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 380: /* func_type: Typename */ + case 383: #line 563 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.typnam) = (yyvsp[0].typnam); } -#line 22221 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 381: /* func_type: type_function_name attrs '%' TYPE_P */ + case 384: #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 22231 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->location = (yylsp[(1) - (4)]); + ;} break; - case 382: /* func_type: SETOF type_function_name attrs '%' TYPE_P */ + case 385: #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 22242 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->location = (yylsp[(2) - (5)]); + ;} break; - case 383: /* ConstraintElem: CHECK_P '(' a_expr ')' ConstraintAttributeSpec */ + case 386: #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 22259 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 384: /* ConstraintElem: UNIQUE '(' columnList_opt_comma ')' opt_definition ConstraintAttributeSpec */ + case 387: #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 22276 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 385: /* ConstraintElem: UNIQUE ExistingIndex ConstraintAttributeSpec */ + case 388: #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 22294 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 386: /* ConstraintElem: PRIMARY KEY '(' columnList_opt_comma ')' opt_definition ConstraintAttributeSpec */ + case 389: #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 22311 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 387: /* ConstraintElem: PRIMARY KEY ExistingIndex ConstraintAttributeSpec */ + case 390: #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 22329 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 388: /* ConstraintElem: FOREIGN KEY '(' columnList_opt_comma ')' REFERENCES qualified_name opt_column_list key_match key_actions ConstraintAttributeSpec */ + case 391: #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 22351 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 389: /* TableElementList: TableElement */ + case 392: #line 674 "third_party/libpg_query/grammar/statements/create.y" - { - (yyval.list) = list_make1((yyvsp[0].node)); - } -#line 22359 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); + ;} break; - case 390: /* TableElementList: TableElementList ',' TableElement */ + case 393: #line 678 "third_party/libpg_query/grammar/statements/create.y" - { - (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].node)); - } -#line 22367 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); + ;} break; - case 391: /* key_match: MATCH FULL */ + case 394: #line 685 "third_party/libpg_query/grammar/statements/create.y" - { + { (yyval.ival) = PG_FKCONSTR_MATCH_FULL; - } -#line 22375 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 392: /* key_match: MATCH PARTIAL */ + case 395: #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 22387 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 393: /* key_match: MATCH SIMPLE */ + case 396: #line 697 "third_party/libpg_query/grammar/statements/create.y" - { + { (yyval.ival) = PG_FKCONSTR_MATCH_SIMPLE; - } -#line 22395 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 394: /* key_match: %empty */ + case 397: #line 701 "third_party/libpg_query/grammar/statements/create.y" - { + { (yyval.ival) = PG_FKCONSTR_MATCH_SIMPLE; - } -#line 22403 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 395: /* TableLikeClause: LIKE qualified_name TableLikeOptionList */ + case 398: #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 22414 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 396: /* OptTemp: TEMPORARY */ + case 399: #line 718 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_RELPERSISTENCE_TEMP; } -#line 22420 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_RELPERSISTENCE_TEMP; ;} break; - case 397: /* OptTemp: TEMP */ + case 400: #line 719 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_RELPERSISTENCE_TEMP; } -#line 22426 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_RELPERSISTENCE_TEMP; ;} break; - case 398: /* OptTemp: LOCAL TEMPORARY */ + case 401: #line 720 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_RELPERSISTENCE_TEMP; } -#line 22432 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_RELPERSISTENCE_TEMP; ;} break; - case 399: /* OptTemp: LOCAL TEMP */ + case 402: #line 721 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_RELPERSISTENCE_TEMP; } -#line 22438 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_RELPERSISTENCE_TEMP; ;} break; - case 400: /* OptTemp: GLOBAL TEMPORARY */ + case 403: #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 22449 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 401: /* OptTemp: GLOBAL TEMP */ + case 404: #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 22460 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 402: /* OptTemp: UNLOGGED */ + case 405: #line 736 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_RELPERSISTENCE_UNLOGGED; } -#line 22466 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_RELPERSISTENCE_UNLOGGED; ;} break; - case 403: /* OptTemp: %empty */ + case 406: #line 737 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = RELPERSISTENCE_PERMANENT; } -#line 22472 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = RELPERSISTENCE_PERMANENT; ;} break; - case 404: /* generated_when: ALWAYS */ + case 407: #line 742 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = PG_ATTRIBUTE_IDENTITY_ALWAYS; } -#line 22478 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_ATTRIBUTE_IDENTITY_ALWAYS; ;} break; - case 405: /* generated_when: BY DEFAULT */ + case 408: #line 743 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = ATTRIBUTE_IDENTITY_BY_DEFAULT; } -#line 22484 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = ATTRIBUTE_IDENTITY_BY_DEFAULT; ;} break; - case 406: /* DropStmt: DROP drop_type_any_name IF_P EXISTS any_name_list opt_drop_behavior */ + case 409: #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 22498 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 407: /* DropStmt: DROP drop_type_any_name any_name_list opt_drop_behavior */ + case 410: #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 22512 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 408: /* DropStmt: DROP drop_type_name IF_P EXISTS name_list opt_drop_behavior */ + case 411: #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 22526 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 409: /* DropStmt: DROP drop_type_name name_list opt_drop_behavior */ + case 412: #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 22540 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 410: /* DropStmt: DROP drop_type_name_on_any_name name ON any_name opt_drop_behavior */ + case 413: #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 22554 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 411: /* DropStmt: DROP drop_type_name_on_any_name IF_P EXISTS name ON any_name opt_drop_behavior */ + case 414: #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 22568 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 412: /* drop_type_any_name: TABLE */ + case 415: #line 73 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_TABLE; } -#line 22574 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_TABLE; ;} break; - case 413: /* drop_type_any_name: SEQUENCE */ + case 416: #line 74 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_SEQUENCE; } -#line 22580 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_SEQUENCE; ;} break; - case 414: /* drop_type_any_name: FUNCTION */ + case 417: #line 75 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_FUNCTION; } -#line 22586 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_FUNCTION; ;} break; - case 415: /* drop_type_any_name: MACRO */ + case 418: #line 76 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_FUNCTION; } -#line 22592 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_FUNCTION; ;} break; - case 416: /* drop_type_any_name: MACRO TABLE */ + case 419: #line 77 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_TABLE_MACRO; } -#line 22598 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_TABLE_MACRO; ;} break; - case 417: /* drop_type_any_name: VIEW */ + case 420: #line 78 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_VIEW; } -#line 22604 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_VIEW; ;} break; - case 418: /* drop_type_any_name: MATERIALIZED VIEW */ + case 421: #line 79 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_MATVIEW; } -#line 22610 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_MATVIEW; ;} break; - case 419: /* drop_type_any_name: INDEX */ + case 422: #line 80 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_INDEX; } -#line 22616 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_INDEX; ;} break; - case 420: /* drop_type_any_name: FOREIGN TABLE */ + case 423: #line 81 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_FOREIGN_TABLE; } -#line 22622 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_FOREIGN_TABLE; ;} break; - case 421: /* drop_type_any_name: COLLATION */ + case 424: #line 82 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_COLLATION; } -#line 22628 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_COLLATION; ;} break; - case 422: /* drop_type_any_name: CONVERSION_P */ + case 425: #line 83 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_CONVERSION; } -#line 22634 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_CONVERSION; ;} break; - case 423: /* drop_type_any_name: SCHEMA */ + case 426: #line 84 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_SCHEMA; } -#line 22640 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_SCHEMA; ;} break; - case 424: /* drop_type_any_name: STATISTICS */ + case 427: #line 85 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_STATISTIC_EXT; } -#line 22646 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_STATISTIC_EXT; ;} break; - case 425: /* drop_type_any_name: TEXT_P SEARCH PARSER */ + case 428: #line 86 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_TSPARSER; } -#line 22652 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_TSPARSER; ;} break; - case 426: /* drop_type_any_name: TEXT_P SEARCH DICTIONARY */ + case 429: #line 87 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_TSDICTIONARY; } -#line 22658 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_TSDICTIONARY; ;} break; - case 427: /* drop_type_any_name: TEXT_P SEARCH TEMPLATE */ + case 430: #line 88 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_TSTEMPLATE; } -#line 22664 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_TSTEMPLATE; ;} break; - case 428: /* drop_type_any_name: TEXT_P SEARCH CONFIGURATION */ + case 431: #line 89 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_TSCONFIGURATION; } -#line 22670 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_TSCONFIGURATION; ;} break; - case 429: /* drop_type_any_name: TYPE_P */ + case 432: #line 90 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_TYPE; } -#line 22676 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_TYPE; ;} break; - case 430: /* drop_type_name: ACCESS METHOD */ + case 433: #line 95 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_ACCESS_METHOD; } -#line 22682 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_ACCESS_METHOD; ;} break; - case 431: /* drop_type_name: EVENT TRIGGER */ + case 434: #line 96 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_EVENT_TRIGGER; } -#line 22688 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_EVENT_TRIGGER; ;} break; - case 432: /* drop_type_name: EXTENSION */ + case 435: #line 97 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_EXTENSION; } -#line 22694 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_EXTENSION; ;} break; - case 433: /* drop_type_name: FOREIGN DATA_P WRAPPER */ + case 436: #line 98 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_FDW; } -#line 22700 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_FDW; ;} break; - case 434: /* drop_type_name: PUBLICATION */ + case 437: #line 99 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_PUBLICATION; } -#line 22706 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_PUBLICATION; ;} break; - case 435: /* drop_type_name: SERVER */ + case 438: #line 100 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_FOREIGN_SERVER; } -#line 22712 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_FOREIGN_SERVER; ;} break; - case 436: /* any_name_list: any_name */ + case 439: #line 105 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.list) = list_make1((yyvsp[0].list)); } -#line 22718 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].list)); ;} break; - case 437: /* any_name_list: any_name_list ',' any_name */ + case 440: #line 106 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].list)); } -#line 22724 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); ;} break; - case 438: /* opt_drop_behavior: CASCADE */ + case 441: #line 111 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.dbehavior) = PG_DROP_CASCADE; } -#line 22730 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.dbehavior) = PG_DROP_CASCADE; ;} break; - case 439: /* opt_drop_behavior: RESTRICT */ + case 442: #line 112 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.dbehavior) = PG_DROP_RESTRICT; } -#line 22736 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.dbehavior) = PG_DROP_RESTRICT; ;} break; - case 440: /* opt_drop_behavior: %empty */ + case 443: #line 113 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.dbehavior) = PG_DROP_RESTRICT; /* default */ } -#line 22742 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.dbehavior) = PG_DROP_RESTRICT; /* default */ ;} break; - case 441: /* drop_type_name_on_any_name: POLICY */ + case 444: #line 118 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_POLICY; } -#line 22748 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_POLICY; ;} break; - case 442: /* drop_type_name_on_any_name: RULE */ + case 445: #line 119 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_RULE; } -#line 22754 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_RULE; ;} break; - case 443: /* drop_type_name_on_any_name: TRIGGER */ + case 446: #line 120 "third_party/libpg_query/grammar/statements/drop.y" - { (yyval.objtype) = PG_OBJECT_TRIGGER; } -#line 22760 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_TRIGGER; ;} break; - case 444: /* CreateFunctionStmt: CREATE_P OptTemp macro_alias qualified_name param_list AS TABLE SelectStmt */ + case 447: #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 22775 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 445: /* CreateFunctionStmt: CREATE_P OptTemp macro_alias IF_P NOT EXISTS qualified_name param_list AS TABLE SelectStmt */ + case 448: #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 22791 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 446: /* CreateFunctionStmt: CREATE_P OR REPLACE OptTemp macro_alias qualified_name param_list AS TABLE SelectStmt */ + case 449: #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 22807 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 447: /* CreateFunctionStmt: CREATE_P OptTemp macro_alias qualified_name param_list AS a_expr */ + case 450: #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 22822 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 448: /* CreateFunctionStmt: CREATE_P OptTemp macro_alias IF_P NOT EXISTS qualified_name param_list AS a_expr */ + case 451: #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 22837 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 449: /* CreateFunctionStmt: CREATE_P OR REPLACE OptTemp macro_alias qualified_name param_list AS a_expr */ + case 452: #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 22852 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 452: /* param_list: '(' ')' */ + case 455: #line 92 "third_party/libpg_query/grammar/statements/create_function.y" - { + { (yyval.list) = NIL; - } -#line 22860 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 453: /* param_list: '(' func_arg_list ')' */ + case 456: #line 96 "third_party/libpg_query/grammar/statements/create_function.y" - { - (yyval.list) = (yyvsp[-1].list); - } -#line 22868 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = (yyvsp[(2) - (3)].list); + ;} break; - case 454: /* UpdateStmt: opt_with_clause UPDATE relation_expr_opt_alias SET set_clause_list_opt_comma from_clause where_or_current_clause returning_clause */ + case 457: #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 22883 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 455: /* 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 458: #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 22915 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 456: /* CopyStmt: COPY '(' SelectStmt ')' TO opt_program copy_file_name opt_with copy_options */ + case 459: #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 22938 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 457: /* CopyStmt: COPY FROM DATABASE ColId TO ColId copy_database_flag */ + case 460: #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 22950 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 458: /* copy_database_flag: %empty */ + case 461: #line 61 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.conststr) = NULL; } -#line 22956 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.conststr) = NULL; ;} break; - case 459: /* copy_database_flag: '(' SCHEMA ')' */ + case 462: #line 62 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.conststr) = "schema"; } -#line 22962 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.conststr) = "schema"; ;} break; - case 460: /* copy_database_flag: '(' DATA_P ')' */ + case 463: #line 63 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.conststr) = "data"; } -#line 22968 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.conststr) = "data"; ;} break; - case 461: /* copy_from: FROM */ + case 464: #line 67 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.boolean) = true; } -#line 22974 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = true; ;} break; - case 462: /* copy_from: TO */ + case 465: #line 68 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.boolean) = false; } -#line 22980 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = false; ;} break; - case 463: /* copy_delimiter: opt_using DELIMITERS Sconst */ + case 466: #line 74 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("delimiter", (PGNode *)makeString((yyvsp[0].str)), (yylsp[-1])); - } -#line 22988 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("delimiter", (PGNode *)makeString((yyvsp[(3) - (3)].str)), (yylsp[(2) - (3)])); + ;} break; - case 464: /* copy_delimiter: %empty */ + case 467: #line 77 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.defelt) = NULL; } -#line 22994 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.defelt) = NULL; ;} break; - case 465: /* copy_generic_opt_arg_list: copy_generic_opt_arg_list_item */ + case 468: #line 83 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.list) = list_make1((yyvsp[0].node)); - } -#line 23002 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); + ;} break; - case 466: /* copy_generic_opt_arg_list: copy_generic_opt_arg_list ',' copy_generic_opt_arg_list_item */ + case 469: #line 87 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].node)); - } -#line 23010 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); + ;} break; - case 467: /* opt_using: USING */ + case 470: #line 94 "third_party/libpg_query/grammar/statements/copy.y" - {} -#line 23016 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 468: /* opt_using: %empty */ + case 471: #line 95 "third_party/libpg_query/grammar/statements/copy.y" - {} -#line 23022 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 469: /* opt_as: AS */ + case 472: #line 99 "third_party/libpg_query/grammar/statements/copy.y" - {} -#line 23028 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 470: /* opt_as: %empty */ + case 473: #line 100 "third_party/libpg_query/grammar/statements/copy.y" - {} -#line 23034 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 471: /* opt_program: PROGRAM */ + case 474: #line 105 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.boolean) = true; } -#line 23040 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = true; ;} break; - case 472: /* opt_program: %empty */ + case 475: #line 106 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.boolean) = false; } -#line 23046 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = false; ;} break; - case 473: /* copy_options: copy_opt_list */ + case 476: #line 110 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.list) = (yyvsp[0].list); } -#line 23052 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 474: /* copy_options: '(' copy_generic_opt_list ')' */ + case 477: #line 111 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 23058 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 475: /* copy_generic_opt_arg: opt_boolean_or_string */ + case 478: #line 116 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.node) = (PGNode *) makeString((yyvsp[0].str)); } -#line 23064 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeString((yyvsp[(1) - (1)].str)); ;} break; - case 476: /* copy_generic_opt_arg: NumericOnly */ + case 479: #line 117 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.node) = (PGNode *) (yyvsp[0].value); } -#line 23070 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) (yyvsp[(1) - (1)].value); ;} break; - case 477: /* copy_generic_opt_arg: list_expr */ + case 480: #line 118 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.node) = (PGNode *) (yyvsp[0].node); } -#line 23076 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) (yyvsp[(1) - (1)].node); ;} break; - case 478: /* copy_generic_opt_arg: '*' */ + case 481: #line 119 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.node) = (PGNode *) makeNode(PGAStar); } -#line 23082 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeNode(PGAStar); ;} break; - case 479: /* copy_generic_opt_arg: '(' copy_generic_opt_arg_list ')' */ + case 482: #line 120 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.node) = (PGNode *) (yyvsp[-1].list); } -#line 23088 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) (yyvsp[(2) - (3)].list); ;} break; - case 480: /* copy_generic_opt_arg: struct_expr */ + case 483: #line 121 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.node) = (PGNode *) (yyvsp[0].node); } -#line 23094 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) (yyvsp[(1) - (1)].node); ;} break; - case 481: /* copy_generic_opt_arg: %empty */ + case 484: #line 122 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.node) = NULL; } -#line 23100 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = NULL; ;} break; - case 482: /* copy_generic_opt_elem: ColLabel copy_generic_opt_arg */ + case 485: #line 128 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem((yyvsp[-1].str), (yyvsp[0].node), (yylsp[-1])); - } -#line 23108 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); + ;} break; - case 483: /* opt_oids: WITH OIDS */ + case 486: #line 136 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("oids", (PGNode *)makeInteger(true), (yylsp[-1])); - } -#line 23116 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("oids", (PGNode *)makeInteger(true), (yylsp[(1) - (2)])); + ;} break; - case 484: /* opt_oids: %empty */ + case 487: #line 139 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.defelt) = NULL; } -#line 23122 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.defelt) = NULL; ;} break; - case 485: /* copy_opt_list: copy_opt_list copy_opt_item */ + case 488: #line 144 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.list) = lappend((yyvsp[-1].list), (yyvsp[0].defelt)); } -#line 23128 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].defelt)); ;} break; - case 486: /* copy_opt_list: %empty */ + case 489: #line 145 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.list) = NIL; } -#line 23134 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 487: /* opt_binary: BINARY */ + case 490: #line 151 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("format", (PGNode *)makeString("binary"), (yylsp[0])); - } -#line 23142 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("format", (PGNode *)makeString("binary"), (yylsp[(1) - (1)])); + ;} break; - case 488: /* opt_binary: %empty */ + case 491: #line 154 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.defelt) = NULL; } -#line 23148 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.defelt) = NULL; ;} break; - case 489: /* copy_opt_item: BINARY */ + case 492: #line 160 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("format", (PGNode *)makeString("binary"), (yylsp[0])); - } -#line 23156 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("format", (PGNode *)makeString("binary"), (yylsp[(1) - (1)])); + ;} break; - case 490: /* copy_opt_item: OIDS */ + case 493: #line 164 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("oids", (PGNode *)makeInteger(true), (yylsp[0])); - } -#line 23164 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("oids", (PGNode *)makeInteger(true), (yylsp[(1) - (1)])); + ;} break; - case 491: /* copy_opt_item: FREEZE */ + case 494: #line 168 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("freeze", (PGNode *)makeInteger(true), (yylsp[0])); - } -#line 23172 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("freeze", (PGNode *)makeInteger(true), (yylsp[(1) - (1)])); + ;} break; - case 492: /* copy_opt_item: DELIMITER opt_as Sconst */ + case 495: #line 172 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("delimiter", (PGNode *)makeString((yyvsp[0].str)), (yylsp[-2])); - } -#line 23180 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("delimiter", (PGNode *)makeString((yyvsp[(3) - (3)].str)), (yylsp[(1) - (3)])); + ;} break; - case 493: /* copy_opt_item: NULL_P opt_as Sconst */ + case 496: #line 176 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("null", (PGNode *)makeString((yyvsp[0].str)), (yylsp[-2])); - } -#line 23188 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("null", (PGNode *)makeString((yyvsp[(3) - (3)].str)), (yylsp[(1) - (3)])); + ;} break; - case 494: /* copy_opt_item: CSV */ + case 497: #line 180 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("format", (PGNode *)makeString("csv"), (yylsp[0])); - } -#line 23196 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("format", (PGNode *)makeString("csv"), (yylsp[(1) - (1)])); + ;} break; - case 495: /* copy_opt_item: HEADER_P */ + case 498: #line 184 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("header", (PGNode *)makeInteger(true), (yylsp[0])); - } -#line 23204 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("header", (PGNode *)makeInteger(true), (yylsp[(1) - (1)])); + ;} break; - case 496: /* copy_opt_item: QUOTE opt_as Sconst */ + case 499: #line 188 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("quote", (PGNode *)makeString((yyvsp[0].str)), (yylsp[-2])); - } -#line 23212 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("quote", (PGNode *)makeString((yyvsp[(3) - (3)].str)), (yylsp[(1) - (3)])); + ;} break; - case 497: /* copy_opt_item: ESCAPE opt_as Sconst */ + case 500: #line 192 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("escape", (PGNode *)makeString((yyvsp[0].str)), (yylsp[-2])); - } -#line 23220 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("escape", (PGNode *)makeString((yyvsp[(3) - (3)].str)), (yylsp[(1) - (3)])); + ;} break; - case 498: /* copy_opt_item: FORCE QUOTE columnList */ + case 501: #line 196 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("force_quote", (PGNode *)(yyvsp[0].list), (yylsp[-2])); - } -#line 23228 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("force_quote", (PGNode *)(yyvsp[(3) - (3)].list), (yylsp[(1) - (3)])); + ;} break; - case 499: /* copy_opt_item: FORCE QUOTE '*' */ + case 502: #line 200 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("force_quote", (PGNode *)makeNode(PGAStar), (yylsp[-2])); - } -#line 23236 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("force_quote", (PGNode *)makeNode(PGAStar), (yylsp[(1) - (3)])); + ;} break; - case 500: /* copy_opt_item: PARTITION BY columnList */ + case 503: #line 204 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("partition_by", (PGNode *)(yyvsp[0].list), (yylsp[-2])); - } -#line 23244 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("partition_by", (PGNode *)(yyvsp[(3) - (3)].list), (yylsp[(1) - (3)])); + ;} break; - case 501: /* copy_opt_item: PARTITION BY '*' */ + case 504: #line 208 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("partition_by", (PGNode *)makeNode(PGAStar), (yylsp[-2])); - } -#line 23252 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("partition_by", (PGNode *)makeNode(PGAStar), (yylsp[(1) - (3)])); + ;} break; - case 502: /* copy_opt_item: FORCE NOT NULL_P columnList */ + case 505: #line 212 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("force_not_null", (PGNode *)(yyvsp[0].list), (yylsp[-3])); - } -#line 23260 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("force_not_null", (PGNode *)(yyvsp[(4) - (4)].list), (yylsp[(1) - (4)])); + ;} break; - case 503: /* copy_opt_item: FORCE NULL_P columnList */ + case 506: #line 216 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("force_null", (PGNode *)(yyvsp[0].list), (yylsp[-2])); - } -#line 23268 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("force_null", (PGNode *)(yyvsp[(3) - (3)].list), (yylsp[(1) - (3)])); + ;} break; - case 504: /* copy_opt_item: ENCODING Sconst */ + case 507: #line 220 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.defelt) = makeDefElem("encoding", (PGNode *)makeString((yyvsp[0].str)), (yylsp[-1])); - } -#line 23276 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem("encoding", (PGNode *)makeString((yyvsp[(2) - (2)].str)), (yylsp[(1) - (2)])); + ;} break; - case 505: /* copy_generic_opt_arg_list_item: opt_boolean_or_string */ + case 508: #line 227 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.node) = (PGNode *) makeString((yyvsp[0].str)); } -#line 23282 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeString((yyvsp[(1) - (1)].str)); ;} break; - case 506: /* copy_file_name: Sconst */ + case 509: #line 232 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.str) = (yyvsp[0].str); } -#line 23288 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 507: /* copy_file_name: STDIN */ + case 510: #line 233 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.str) = NULL; } -#line 23294 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = NULL; ;} break; - case 508: /* copy_file_name: STDOUT */ + case 511: #line 234 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.str) = NULL; } -#line 23300 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = NULL; ;} break; - case 509: /* copy_file_name: IDENT '.' ColId */ + case 512: #line 235 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.str) = psprintf("%s.%s", (yyvsp[-2].str), (yyvsp[0].str)); } -#line 23306 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = psprintf("%s.%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)); ;} break; - case 510: /* copy_file_name: IDENT */ + case 513: #line 236 "third_party/libpg_query/grammar/statements/copy.y" - { (yyval.str) = (yyvsp[0].str); } -#line 23312 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 511: /* copy_generic_opt_list: copy_generic_opt_elem */ + case 514: #line 243 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.list) = list_make1((yyvsp[0].defelt)); - } -#line 23320 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); + ;} break; - case 512: /* copy_generic_opt_list: copy_generic_opt_list ',' copy_generic_opt_elem */ + case 515: #line 247 "third_party/libpg_query/grammar/statements/copy.y" - { - (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].defelt)); - } -#line 23328 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt)); + ;} break; - case 515: /* select_with_parens: '(' select_no_parens ')' */ + case 518: #line 52 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[-1].node); } -#line 23334 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(2) - (3)].node); ;} break; - case 516: /* select_with_parens: '(' select_with_parens ')' */ + case 519: #line 53 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[-1].node); } -#line 23340 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(2) - (3)].node); ;} break; - case 517: /* select_with_parens: '(' VariableShowStmt ')' */ + case 520: #line 55 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (yyvsp[-1].node); - } -#line 23348 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (yyvsp[(2) - (3)].node); + ;} break; - case 518: /* select_no_parens: simple_select */ + case 521: #line 72 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 23354 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 519: /* select_no_parens: select_clause sort_clause */ + case 522: #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 23365 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = (yyvsp[(1) - (2)].node); + ;} break; - case 520: /* select_no_parens: select_clause opt_sort_clause for_locking_clause opt_select_limit */ + case 523: #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 23377 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = (yyvsp[(1) - (4)].node); + ;} break; - case 521: /* select_no_parens: select_clause opt_sort_clause select_limit opt_for_locking_clause */ + case 524: #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 23389 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = (yyvsp[(1) - (4)].node); + ;} break; - case 522: /* select_no_parens: with_clause select_clause */ + case 525: #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 23401 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = (yyvsp[(2) - (2)].node); + ;} break; - case 523: /* select_no_parens: with_clause select_clause sort_clause */ + case 526: #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 23413 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = (yyvsp[(2) - (3)].node); + ;} break; - case 524: /* select_no_parens: with_clause select_clause opt_sort_clause for_locking_clause opt_select_limit */ + case 527: #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 23425 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = (yyvsp[(2) - (5)].node); + ;} break; - case 525: /* select_no_parens: with_clause select_clause opt_sort_clause select_limit opt_for_locking_clause */ + case 528: #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 23437 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = (yyvsp[(2) - (5)].node); + ;} break; - case 526: /* select_clause: simple_select */ + case 529: #line 131 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 23443 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 527: /* select_clause: select_with_parens */ + case 530: #line 132 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 23449 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 528: /* opt_select: SELECT opt_all_clause opt_target_list_opt_comma */ + case 531: #line 160 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = (yyvsp[0].list); - } -#line 23457 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = (yyvsp[(3) - (3)].list); + ;} break; - case 529: /* opt_select: %empty */ + case 532: #line 164 "third_party/libpg_query/grammar/statements/select.y" - { + { PGAStar *star = makeNode(PGAStar); (yyval.list) = list_make1(star); - } -#line 23466 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 530: /* 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 533: #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 23484 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 531: /* 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 534: #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 23503 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 532: /* simple_select: FROM from_list opt_select into_clause where_clause group_clause having_clause window_clause qualify_clause sample_clause */ + case 535: #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 23521 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 533: /* 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 536: #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 23540 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 534: /* simple_select: values_clause_opt_comma */ + case 537: #line 239 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 23546 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 535: /* simple_select: TABLE relation_expr */ + case 538: #line 241 "third_party/libpg_query/grammar/statements/select.y" - { + { /* same as SELECT * FROM relation_expr */ PGColumnRef *cr = makeNode(PGColumnRef); PGResTarget *rt = makeNode(PGResTarget); @@ -23562,1989 +24137,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 23569 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 536: /* simple_select: select_clause UNION all_or_distinct by_name select_clause */ + case 539: #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 23577 "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 537: /* simple_select: select_clause UNION all_or_distinct select_clause */ + case 540: #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 23585 "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 538: /* simple_select: select_clause INTERSECT all_or_distinct select_clause */ + case 541: #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 23593 "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 539: /* simple_select: select_clause EXCEPT all_or_distinct select_clause */ + case 542: #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 23601 "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 540: /* simple_select: pivot_keyword table_ref USING target_list_opt_comma */ + case 543: #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->location = (yylsp[-3]); + 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 23615 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 541: /* simple_select: pivot_keyword table_ref USING target_list_opt_comma GROUP_P BY name_list_opt_comma_opt_bracket */ + case 544: #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->location = (yylsp[-6]); + 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 23630 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 542: /* simple_select: pivot_keyword table_ref GROUP_P BY name_list_opt_comma_opt_bracket */ + case 545: #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->location = (yylsp[-4]); + 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 23644 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 543: /* simple_select: pivot_keyword table_ref ON pivot_column_list */ + case 546: #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 23657 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 544: /* simple_select: pivot_keyword table_ref ON pivot_column_list GROUP_P BY name_list_opt_comma_opt_bracket */ + case 547: #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->location = (yylsp[-6]); + 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 23672 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 545: /* simple_select: pivot_keyword table_ref ON pivot_column_list USING target_list_opt_comma */ + case 548: #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->location = (yylsp[-5]); + 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 23687 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 546: /* simple_select: pivot_keyword table_ref ON pivot_column_list USING target_list_opt_comma GROUP_P BY name_list_opt_comma_opt_bracket */ + case 549: #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->location = (yylsp[-8]); + 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 23703 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 547: /* simple_select: unpivot_keyword table_ref ON target_list_opt_comma INTO NAME_P name value_or_values name_list_opt_comma_opt_bracket */ + case 550: #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->location = (yylsp[-8]); + 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 23722 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 548: /* simple_select: unpivot_keyword table_ref ON target_list_opt_comma */ + case 551: #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[-3]); + 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 23741 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 555: /* pivot_column_entry: b_expr */ + case 558: #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 23751 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 556: /* pivot_column_entry: b_expr IN_P '(' select_no_parens ')' */ + case 559: #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 23762 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 557: /* pivot_column_entry: single_pivot_value */ + case 560: #line 407 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 23768 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 558: /* pivot_column_list_internal: pivot_column_entry */ + case 561: #line 411 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].node)); } -#line 23774 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 559: /* pivot_column_list_internal: pivot_column_list_internal ',' pivot_column_entry */ + case 562: #line 412 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].node)); } -#line 23780 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; - case 560: /* pivot_column_list: pivot_column_list_internal */ + case 563: #line 416 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 23786 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 561: /* pivot_column_list: pivot_column_list_internal ',' */ + case 564: #line 417 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 23792 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 562: /* with_clause: WITH cte_list */ + case 565: #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 23803 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.with)->location = (yylsp[(1) - (2)]); + ;} break; - case 563: /* with_clause: WITH_LA cte_list */ + case 566: #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 23814 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.with)->location = (yylsp[(1) - (2)]); + ;} break; - case 564: /* with_clause: WITH RECURSIVE cte_list */ + case 567: #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 23825 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.with)->location = (yylsp[(1) - (3)]); + ;} break; - case 565: /* cte_list: common_table_expr */ + case 568: #line 455 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].node)); } -#line 23831 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 566: /* cte_list: cte_list ',' common_table_expr */ + case 569: #line 456 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].node)); } -#line 23837 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; - case 567: /* common_table_expr: name opt_name_list AS opt_materialized '(' PreparableStmt ')' */ + case 570: #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 23851 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 568: /* opt_materialized: MATERIALIZED */ + case 571: #line 472 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ctematerialize) = PGCTEMaterializeAlways; } -#line 23857 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ctematerialize) = PGCTEMaterializeAlways; ;} break; - case 569: /* opt_materialized: NOT MATERIALIZED */ + case 572: #line 473 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ctematerialize) = PGCTEMaterializeNever; } -#line 23863 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ctematerialize) = PGCTEMaterializeNever; ;} break; - case 570: /* opt_materialized: %empty */ + case 573: #line 474 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ctematerialize) = PGCTEMaterializeDefault; } -#line 23869 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ctematerialize) = PGCTEMaterializeDefault; ;} break; - case 571: /* into_clause: INTO OptTempTableName */ + case 574: #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 23883 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 572: /* into_clause: %empty */ + case 575: #line 489 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.into) = NULL; } -#line 23889 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.into) = NULL; ;} break; - case 573: /* OptTempTableName: TEMPORARY opt_table qualified_name */ + case 576: #line 498 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.range) = (yyvsp[0].range); + { + (yyval.range) = (yyvsp[(3) - (3)].range); (yyval.range)->relpersistence = PG_RELPERSISTENCE_TEMP; - } -#line 23898 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 574: /* OptTempTableName: TEMP opt_table qualified_name */ + case 577: #line 503 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.range) = (yyvsp[0].range); + { + (yyval.range) = (yyvsp[(3) - (3)].range); (yyval.range)->relpersistence = PG_RELPERSISTENCE_TEMP; - } -#line 23907 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 575: /* OptTempTableName: LOCAL TEMPORARY opt_table qualified_name */ + case 578: #line 508 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.range) = (yyvsp[0].range); + { + (yyval.range) = (yyvsp[(4) - (4)].range); (yyval.range)->relpersistence = PG_RELPERSISTENCE_TEMP; - } -#line 23916 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 576: /* OptTempTableName: LOCAL TEMP opt_table qualified_name */ + case 579: #line 513 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.range) = (yyvsp[0].range); + { + (yyval.range) = (yyvsp[(4) - (4)].range); (yyval.range)->relpersistence = PG_RELPERSISTENCE_TEMP; - } -#line 23925 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 577: /* OptTempTableName: GLOBAL TEMPORARY opt_table qualified_name */ + case 580: #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 23937 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 578: /* OptTempTableName: GLOBAL TEMP opt_table qualified_name */ + case 581: #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 23949 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 579: /* OptTempTableName: UNLOGGED opt_table qualified_name */ + case 582: #line 534 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.range) = (yyvsp[0].range); + { + (yyval.range) = (yyvsp[(3) - (3)].range); (yyval.range)->relpersistence = PG_RELPERSISTENCE_UNLOGGED; - } -#line 23958 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 580: /* OptTempTableName: TABLE qualified_name */ + case 583: #line 539 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.range) = (yyvsp[0].range); + { + (yyval.range) = (yyvsp[(2) - (2)].range); (yyval.range)->relpersistence = RELPERSISTENCE_PERMANENT; - } -#line 23967 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 581: /* OptTempTableName: qualified_name */ + case 584: #line 544 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.range) = (yyvsp[0].range); + { + (yyval.range) = (yyvsp[(1) - (1)].range); (yyval.range)->relpersistence = RELPERSISTENCE_PERMANENT; - } -#line 23976 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 582: /* opt_table: TABLE */ + case 585: #line 550 "third_party/libpg_query/grammar/statements/select.y" - {} -#line 23982 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 583: /* opt_table: %empty */ + case 586: #line 551 "third_party/libpg_query/grammar/statements/select.y" - {} -#line 23988 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 584: /* all_or_distinct: ALL */ + case 587: #line 555 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = true; } -#line 23994 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = true; ;} break; - case 585: /* all_or_distinct: DISTINCT */ + case 588: #line 556 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = false; } -#line 24000 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = false; ;} break; - case 586: /* all_or_distinct: %empty */ + case 589: #line 557 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = false; } -#line 24006 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = false; ;} break; - case 587: /* by_name: BY NAME_P */ + case 590: #line 561 "third_party/libpg_query/grammar/statements/select.y" - { } -#line 24012 "third_party/libpg_query/grammar/grammar_out.cpp" + { ;} break; - case 588: /* distinct_clause: DISTINCT */ + case 591: #line 568 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(NIL); } -#line 24018 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(NIL); ;} break; - case 589: /* distinct_clause: DISTINCT ON '(' expr_list_opt_comma ')' */ + case 592: #line 569 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 24024 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(4) - (5)].list); ;} break; - case 590: /* opt_all_clause: ALL */ + case 593: #line 573 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL;} -#line 24030 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL;;} break; - case 591: /* opt_all_clause: %empty */ + case 594: #line 574 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 24036 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 592: /* opt_ignore_nulls: IGNORE_P NULLS_P */ + case 595: #line 578 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ignorenulls) = PG_IGNORE_NULLS;} -#line 24042 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ignorenulls) = PG_IGNORE_NULLS;;} break; - case 593: /* opt_ignore_nulls: RESPECT_P NULLS_P */ + case 596: #line 579 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ignorenulls) = PG_RESPECT_NULLS;} -#line 24048 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ignorenulls) = PG_RESPECT_NULLS;;} break; - case 594: /* opt_ignore_nulls: %empty */ + case 597: #line 580 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ignorenulls) = PG_DEFAULT_NULLS; } -#line 24054 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ignorenulls) = PG_DEFAULT_NULLS; ;} break; - case 595: /* opt_sort_clause: sort_clause */ + case 598: #line 584 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list);} -#line 24060 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list);;} break; - case 596: /* opt_sort_clause: %empty */ + case 599: #line 585 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 24066 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 597: /* sort_clause: ORDER BY sortby_list */ + case 600: #line 589 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 24072 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(3) - (3)].list); ;} break; - case 598: /* sort_clause: ORDER BY ALL opt_asc_desc opt_nulls_order */ + case 601: #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 24089 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 599: /* sortby_list: sortby */ + case 602: #line 606 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].sortby)); } -#line 24095 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].sortby)); ;} break; - case 600: /* sortby_list: sortby_list ',' sortby */ + case 603: #line 607 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].sortby)); } -#line 24101 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].sortby)); ;} break; - case 601: /* sortby: a_expr USING qual_all_Op opt_nulls_order */ + case 604: #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 24114 "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 602: /* sortby: a_expr opt_asc_desc opt_nulls_order */ + case 605: #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 24127 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 603: /* opt_asc_desc: ASC_P */ + case 606: #line 630 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.sortorder) = PG_SORTBY_ASC; } -#line 24133 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.sortorder) = PG_SORTBY_ASC; ;} break; - case 604: /* opt_asc_desc: DESC_P */ + case 607: #line 631 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.sortorder) = PG_SORTBY_DESC; } -#line 24139 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.sortorder) = PG_SORTBY_DESC; ;} break; - case 605: /* opt_asc_desc: %empty */ + case 608: #line 632 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.sortorder) = PG_SORTBY_DEFAULT; } -#line 24145 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.sortorder) = PG_SORTBY_DEFAULT; ;} break; - case 606: /* opt_nulls_order: NULLS_LA FIRST_P */ + case 609: #line 635 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.nullorder) = PG_SORTBY_NULLS_FIRST; } -#line 24151 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.nullorder) = PG_SORTBY_NULLS_FIRST; ;} break; - case 607: /* opt_nulls_order: NULLS_LA LAST_P */ + case 610: #line 636 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.nullorder) = PG_SORTBY_NULLS_LAST; } -#line 24157 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.nullorder) = PG_SORTBY_NULLS_LAST; ;} break; - case 608: /* opt_nulls_order: %empty */ + case 611: #line 637 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.nullorder) = PG_SORTBY_NULLS_DEFAULT; } -#line 24163 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.nullorder) = PG_SORTBY_NULLS_DEFAULT; ;} break; - case 609: /* select_limit: limit_clause offset_clause */ + case 612: #line 641 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make2((yyvsp[0].node), (yyvsp[-1].node)); } -#line 24169 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make2((yyvsp[(2) - (2)].node), (yyvsp[(1) - (2)].node)); ;} break; - case 610: /* select_limit: offset_clause limit_clause */ + case 613: #line 642 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make2((yyvsp[-1].node), (yyvsp[0].node)); } -#line 24175 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make2((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node)); ;} break; - case 611: /* select_limit: limit_clause */ + case 614: #line 643 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make2(NULL, (yyvsp[0].node)); } -#line 24181 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make2(NULL, (yyvsp[(1) - (1)].node)); ;} break; - case 612: /* select_limit: offset_clause */ + case 615: #line 644 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make2((yyvsp[0].node), NULL); } -#line 24187 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make2((yyvsp[(1) - (1)].node), NULL); ;} break; - case 613: /* opt_select_limit: select_limit */ + case 616: #line 648 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 24193 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 614: /* opt_select_limit: %empty */ + case 617: #line 649 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make2(NULL,NULL); } -#line 24199 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make2(NULL,NULL); ;} break; - case 615: /* limit_clause: LIMIT select_limit_value */ + case 618: #line 654 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 24205 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 616: /* limit_clause: LIMIT select_limit_value ',' select_offset_value */ + case 619: #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 24218 "third_party/libpg_query/grammar/grammar_out.cpp" + parser_errposition((yylsp[(1) - (4)])))); + ;} break; - case 617: /* limit_clause: FETCH first_or_next select_fetch_first_value row_or_rows ONLY */ + case 620: #line 672 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[-2].node); } -#line 24224 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(3) - (5)].node); ;} break; - case 618: /* limit_clause: FETCH first_or_next row_or_rows ONLY */ + case 621: #line 674 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = makeIntConst(1, -1); } -#line 24230 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = makeIntConst(1, -1); ;} break; - case 619: /* offset_clause: OFFSET select_offset_value */ + case 622: #line 679 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 24236 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 620: /* offset_clause: OFFSET select_fetch_first_value row_or_rows */ + case 623: #line 682 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[-1].node); } -#line 24242 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(2) - (3)].node); ;} break; - case 621: /* sample_count: FCONST '%' */ + case 624: #line 690 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeSampleSize(makeFloat((yyvsp[-1].str)), true); - } -#line 24250 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeSampleSize(makeFloat((yyvsp[(1) - (2)].str)), true); + ;} break; - case 622: /* sample_count: ICONST '%' */ + case 625: #line 694 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeSampleSize(makeInteger((yyvsp[-1].ival)), true); - } -#line 24258 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeSampleSize(makeInteger((yyvsp[(1) - (2)].ival)), true); + ;} break; - case 623: /* sample_count: FCONST PERCENT */ + case 626: #line 698 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeSampleSize(makeFloat((yyvsp[-1].str)), true); - } -#line 24266 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeSampleSize(makeFloat((yyvsp[(1) - (2)].str)), true); + ;} break; - case 624: /* sample_count: ICONST PERCENT */ + case 627: #line 702 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeSampleSize(makeInteger((yyvsp[-1].ival)), true); - } -#line 24274 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeSampleSize(makeInteger((yyvsp[(1) - (2)].ival)), true); + ;} break; - case 625: /* sample_count: ICONST */ + case 628: #line 706 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeSampleSize(makeInteger((yyvsp[0].ival)), false); - } -#line 24282 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeSampleSize(makeInteger((yyvsp[(1) - (1)].ival)), false); + ;} break; - case 626: /* sample_count: ICONST ROWS */ + case 629: #line 710 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeSampleSize(makeInteger((yyvsp[-1].ival)), false); - } -#line 24290 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeSampleSize(makeInteger((yyvsp[(1) - (2)].ival)), false); + ;} break; - case 627: /* sample_clause: USING SAMPLE tablesample_entry */ + case 630: #line 717 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (yyvsp[0].node); - } -#line 24298 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (yyvsp[(3) - (3)].node); + ;} break; - case 628: /* sample_clause: %empty */ + case 631: #line 721 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = NULL; } -#line 24304 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = NULL; ;} break; - case 629: /* opt_sample_func: ColId */ + case 632: #line 728 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (yyvsp[0].str); } -#line 24310 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 630: /* opt_sample_func: %empty */ + case 633: #line 729 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = NULL; } -#line 24316 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = NULL; ;} break; - case 631: /* tablesample_entry: opt_sample_func '(' sample_count ')' opt_repeatable_clause */ + case 634: #line 734 "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 24325 "third_party/libpg_query/grammar/grammar_out.cpp" + { + int seed = (yyvsp[(5) - (5)].ival); + (yyval.node) = makeSampleOptions((yyvsp[(3) - (5)].node), (yyvsp[(1) - (5)].str), &seed, (yylsp[(1) - (5)])); + ;} break; - case 632: /* tablesample_entry: sample_count */ + case 635: #line 739 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeSampleOptions((yyvsp[0].node), NULL, NULL, (yylsp[0])); - } -#line 24333 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeSampleOptions((yyvsp[(1) - (1)].node), NULL, NULL, (yylsp[(1) - (1)])); + ;} break; - case 633: /* tablesample_entry: sample_count '(' ColId ')' */ + case 636: #line 743 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeSampleOptions((yyvsp[-3].node), (yyvsp[-1].str), NULL, (yylsp[-3])); - } -#line 24341 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeSampleOptions((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].str), NULL, (yylsp[(1) - (4)])); + ;} break; - case 634: /* tablesample_entry: sample_count '(' ColId ',' ICONST ')' */ + case 637: #line 747 "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 24350 "third_party/libpg_query/grammar/grammar_out.cpp" + { + int seed = (yyvsp[(5) - (6)].ival); + (yyval.node) = makeSampleOptions((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].str), &seed, (yylsp[(1) - (6)])); + ;} break; - case 635: /* tablesample_clause: TABLESAMPLE tablesample_entry */ + case 638: #line 755 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (yyvsp[0].node); - } -#line 24358 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (yyvsp[(2) - (2)].node); + ;} break; - case 636: /* opt_tablesample_clause: tablesample_clause */ + case 639: #line 761 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 24364 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 637: /* opt_tablesample_clause: %empty */ + case 640: #line 762 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = NULL; } -#line 24370 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = NULL; ;} break; - case 638: /* opt_repeatable_clause: REPEATABLE '(' ICONST ')' */ + case 641: #line 767 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ival) = (yyvsp[-1].ival); } -#line 24376 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = (yyvsp[(3) - (4)].ival); ;} break; - case 639: /* opt_repeatable_clause: %empty */ + case 642: #line 768 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ival) = -1; } -#line 24382 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = -1; ;} break; - case 640: /* select_limit_value: a_expr */ + case 643: #line 772 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 24388 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 641: /* select_limit_value: ALL */ + case 644: #line 774 "third_party/libpg_query/grammar/statements/select.y" - { + { /* LIMIT ALL is represented as a NULL constant */ - (yyval.node) = makeNullAConst((yylsp[0])); - } -#line 24397 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = makeNullAConst((yylsp[(1) - (1)])); + ;} break; - case 642: /* select_limit_value: a_expr '%' */ + case 645: #line 779 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = makeLimitPercent((yyvsp[-1].node)); } -#line 24403 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = makeLimitPercent((yyvsp[(1) - (2)].node)); ;} break; - case 643: /* select_limit_value: FCONST PERCENT */ + case 646: #line 781 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = makeLimitPercent(makeFloatConst((yyvsp[-1].str),(yylsp[-1]))); } -#line 24409 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = makeLimitPercent(makeFloatConst((yyvsp[(1) - (2)].str),(yylsp[(1) - (2)]))); ;} break; - case 644: /* select_limit_value: ICONST PERCENT */ + case 647: #line 783 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = makeLimitPercent(makeIntConst((yyvsp[-1].ival),(yylsp[-1]))); } -#line 24415 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = makeLimitPercent(makeIntConst((yyvsp[(1) - (2)].ival),(yylsp[(1) - (2)]))); ;} break; - case 645: /* select_offset_value: a_expr */ + case 648: #line 787 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 24421 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 646: /* select_fetch_first_value: c_expr */ + case 649: #line 807 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 24427 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 647: /* select_fetch_first_value: '+' I_or_F_const */ + case 650: #line 809 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", NULL, (yyvsp[0].node), (yylsp[-1])); } -#line 24433 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", NULL, (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 648: /* select_fetch_first_value: '-' I_or_F_const */ + case 651: #line 811 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = doNegate((yyvsp[0].node), (yylsp[-1])); } -#line 24439 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = doNegate((yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 649: /* I_or_F_const: Iconst */ + case 652: #line 815 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = makeIntConst((yyvsp[0].ival),(yylsp[0])); } -#line 24445 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = makeIntConst((yyvsp[(1) - (1)].ival),(yylsp[(1) - (1)])); ;} break; - case 650: /* I_or_F_const: FCONST */ + case 653: #line 816 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = makeFloatConst((yyvsp[0].str),(yylsp[0])); } -#line 24451 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = makeFloatConst((yyvsp[(1) - (1)].str),(yylsp[(1) - (1)])); ;} break; - case 651: /* row_or_rows: ROW */ + case 654: #line 820 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ival) = 0; } -#line 24457 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = 0; ;} break; - case 652: /* row_or_rows: ROWS */ + case 655: #line 821 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ival) = 0; } -#line 24463 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = 0; ;} break; - case 653: /* first_or_next: FIRST_P */ + case 656: #line 824 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ival) = 0; } -#line 24469 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = 0; ;} break; - case 654: /* first_or_next: NEXT */ + case 657: #line 825 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ival) = 0; } -#line 24475 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = 0; ;} break; - case 655: /* group_clause: GROUP_P BY group_by_list_opt_comma */ + case 658: #line 850 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 24481 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(3) - (3)].list); ;} break; - case 656: /* group_clause: GROUP_P BY ALL */ + case 659: #line 852 "third_party/libpg_query/grammar/statements/select.y" - { - PGNode *node = (PGNode *) makeGroupingSet(GROUPING_SET_ALL, NIL, (yylsp[0])); + { + PGNode *node = (PGNode *) makeGroupingSet(GROUPING_SET_ALL, NIL, (yylsp[(3) - (3)])); (yyval.list) = list_make1(node); - } -#line 24490 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 657: /* group_clause: %empty */ + case 660: #line 856 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 24496 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 658: /* group_by_list: group_by_item */ + case 661: #line 860 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].node)); } -#line 24502 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 659: /* group_by_list: group_by_list ',' group_by_item */ + case 662: #line 861 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list),(yyvsp[0].node)); } -#line 24508 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list),(yyvsp[(3) - (3)].node)); ;} break; - case 660: /* group_by_list_opt_comma: group_by_list */ + case 663: #line 865 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 24514 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 661: /* group_by_list_opt_comma: group_by_list ',' */ + case 664: #line 866 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 24520 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 662: /* group_by_item: a_expr */ + case 665: #line 870 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 24526 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 663: /* group_by_item: empty_grouping_set */ + case 666: #line 871 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 24532 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 664: /* group_by_item: cube_clause */ + case 667: #line 872 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 24538 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 665: /* group_by_item: rollup_clause */ + case 668: #line 873 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 24544 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 666: /* group_by_item: grouping_sets_clause */ + case 669: #line 874 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 24550 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 667: /* empty_grouping_set: '(' ')' */ + case 670: #line 879 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeGroupingSet(GROUPING_SET_EMPTY, NIL, (yylsp[-1])); - } -#line 24558 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (PGNode *) makeGroupingSet(GROUPING_SET_EMPTY, NIL, (yylsp[(1) - (2)])); + ;} break; - case 668: /* rollup_clause: ROLLUP '(' expr_list_opt_comma ')' */ + case 671: #line 892 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeGroupingSet(GROUPING_SET_ROLLUP, (yyvsp[-1].list), (yylsp[-3])); - } -#line 24566 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (PGNode *) makeGroupingSet(GROUPING_SET_ROLLUP, (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)])); + ;} break; - case 669: /* cube_clause: CUBE '(' expr_list_opt_comma ')' */ + case 672: #line 899 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeGroupingSet(GROUPING_SET_CUBE, (yyvsp[-1].list), (yylsp[-3])); - } -#line 24574 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (PGNode *) makeGroupingSet(GROUPING_SET_CUBE, (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)])); + ;} break; - case 670: /* grouping_sets_clause: GROUPING SETS '(' group_by_list_opt_comma ')' */ + case 673: #line 906 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeGroupingSet(GROUPING_SET_SETS, (yyvsp[-1].list), (yylsp[-4])); - } -#line 24582 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (PGNode *) makeGroupingSet(GROUPING_SET_SETS, (yyvsp[(4) - (5)].list), (yylsp[(1) - (5)])); + ;} break; - case 671: /* grouping_or_grouping_id: GROUPING */ + case 674: #line 912 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = NULL; } -#line 24588 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = NULL; ;} break; - case 672: /* grouping_or_grouping_id: GROUPING_ID */ + case 675: #line 913 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = NULL; } -#line 24594 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = NULL; ;} break; - case 673: /* having_clause: HAVING a_expr */ + case 676: #line 917 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 24600 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 674: /* having_clause: %empty */ + case 677: #line 918 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = NULL; } -#line 24606 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = NULL; ;} break; - case 675: /* qualify_clause: QUALIFY a_expr */ + case 678: #line 922 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 24612 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 676: /* qualify_clause: %empty */ + case 679: #line 923 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = NULL; } -#line 24618 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = NULL; ;} break; - case 677: /* for_locking_clause: for_locking_items */ + case 680: #line 927 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 24624 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 678: /* for_locking_clause: FOR READ_P ONLY */ + case 681: #line 928 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 24630 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 679: /* opt_for_locking_clause: for_locking_clause */ + case 682: #line 932 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 24636 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 680: /* opt_for_locking_clause: %empty */ + case 683: #line 933 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 24642 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 681: /* for_locking_items: for_locking_item */ + case 684: #line 937 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].node)); } -#line 24648 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 682: /* for_locking_items: for_locking_items for_locking_item */ + case 685: #line 938 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-1].list), (yyvsp[0].node)); } -#line 24654 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;} break; - case 683: /* for_locking_item: for_locking_strength locked_rels_list opt_nowait_or_skip */ + case 686: #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 24666 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 684: /* for_locking_strength: FOR UPDATE */ + case 687: #line 953 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.lockstrength) = LCS_FORUPDATE; } -#line 24672 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.lockstrength) = LCS_FORUPDATE; ;} break; - case 685: /* for_locking_strength: FOR NO KEY UPDATE */ + case 688: #line 954 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.lockstrength) = PG_LCS_FORNOKEYUPDATE; } -#line 24678 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.lockstrength) = PG_LCS_FORNOKEYUPDATE; ;} break; - case 686: /* for_locking_strength: FOR SHARE */ + case 689: #line 955 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.lockstrength) = PG_LCS_FORSHARE; } -#line 24684 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.lockstrength) = PG_LCS_FORSHARE; ;} break; - case 687: /* for_locking_strength: FOR KEY SHARE */ + case 690: #line 956 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.lockstrength) = PG_LCS_FORKEYSHARE; } -#line 24690 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.lockstrength) = PG_LCS_FORKEYSHARE; ;} break; - case 688: /* locked_rels_list: OF qualified_name_list */ + case 691: #line 960 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 24696 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (2)].list); ;} break; - case 689: /* locked_rels_list: %empty */ + case 692: #line 961 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 24702 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 690: /* opt_nowait_or_skip: NOWAIT */ + case 693: #line 966 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.lockwaitpolicy) = LockWaitError; } -#line 24708 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.lockwaitpolicy) = LockWaitError; ;} break; - case 691: /* opt_nowait_or_skip: SKIP LOCKED */ + case 694: #line 967 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.lockwaitpolicy) = PGLockWaitSkip; } -#line 24714 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.lockwaitpolicy) = PGLockWaitSkip; ;} break; - case 692: /* opt_nowait_or_skip: %empty */ + case 695: #line 968 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.lockwaitpolicy) = PGLockWaitBlock; } -#line 24720 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.lockwaitpolicy) = PGLockWaitBlock; ;} break; - case 693: /* values_clause: VALUES '(' expr_list_opt_comma ')' */ + case 696: #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 24730 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 694: /* values_clause: values_clause ',' '(' expr_list_opt_comma ')' */ + case 697: #line 984 "third_party/libpg_query/grammar/statements/select.y" - { - PGSelectStmt *n = (PGSelectStmt *) (yyvsp[-4].node); - n->valuesLists = lappend(n->valuesLists, (yyvsp[-1].list)); + { + PGSelectStmt *n = (PGSelectStmt *) (yyvsp[(1) - (5)].node); + n->valuesLists = lappend(n->valuesLists, (yyvsp[(4) - (5)].list)); (yyval.node) = (PGNode *) n; - } -#line 24740 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 695: /* values_clause_opt_comma: values_clause */ + case 698: #line 992 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 24746 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 696: /* values_clause_opt_comma: values_clause ',' */ + case 699: #line 993 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[-1].node); } -#line 24752 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (2)].node); ;} break; - case 697: /* from_clause: FROM from_list_opt_comma */ + case 700: #line 1006 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 24758 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (2)].list); ;} break; - case 698: /* from_clause: %empty */ + case 701: #line 1007 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 24764 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 699: /* from_list: table_ref */ + case 702: #line 1011 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].node)); } -#line 24770 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 700: /* from_list: from_list ',' table_ref */ + case 703: #line 1012 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].node)); } -#line 24776 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; - case 701: /* from_list_opt_comma: from_list */ + case 704: #line 1016 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 24782 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 702: /* from_list_opt_comma: from_list ',' */ + case 705: #line 1017 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 24788 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 703: /* table_ref: relation_expr opt_alias_clause opt_tablesample_clause */ + case 706: #line 1024 "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 24798 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (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 704: /* table_ref: func_table func_alias_clause opt_tablesample_clause */ + case 707: #line 1030 "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); + { + 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 24810 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 705: /* table_ref: values_clause_opt_comma alias_clause opt_tablesample_clause */ + case 708: #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 24823 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 706: /* table_ref: LATERAL_P func_table func_alias_clause */ + case 709: #line 1047 "third_party/libpg_query/grammar/statements/select.y" - { - PGRangeFunction *n = (PGRangeFunction *) (yyvsp[-1].node); + { + 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 24835 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 707: /* table_ref: select_with_parens opt_alias_clause opt_tablesample_clause */ + case 710: #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 24848 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 708: /* table_ref: LATERAL_P select_with_parens opt_alias_clause */ + case 711: #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 24861 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 709: /* table_ref: joined_table */ + case 712: #line 1073 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) (yyvsp[0].jexpr); - } -#line 24869 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (PGNode *) (yyvsp[(1) - (1)].jexpr); + ;} break; - case 710: /* table_ref: '(' joined_table ')' alias_clause */ + case 713: #line 1077 "third_party/libpg_query/grammar/statements/select.y" - { - (yyvsp[-2].jexpr)->alias = (yyvsp[0].alias); - (yyval.node) = (PGNode *) (yyvsp[-2].jexpr); - } -#line 24878 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyvsp[(2) - (4)].jexpr)->alias = (yyvsp[(4) - (4)].alias); + (yyval.node) = (PGNode *) (yyvsp[(2) - (4)].jexpr); + ;} break; - case 711: /* table_ref: table_ref PIVOT '(' target_list_opt_comma FOR pivot_value_list opt_pivot_group_by ')' opt_alias_clause */ + case 714: #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->location = (yylsp[-7]); + 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 24893 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 712: /* table_ref: table_ref UNPIVOT opt_include_nulls '(' unpivot_header FOR unpivot_value_list ')' opt_alias_clause */ + case 715: #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->location = (yylsp[-7]); + 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 24908 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 713: /* opt_pivot_group_by: GROUP_P BY name_list_opt_comma */ + case 716: #line 1106 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 24914 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(3) - (3)].list); ;} break; - case 714: /* opt_pivot_group_by: %empty */ + case 717: #line 1107 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NULL; } -#line 24920 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NULL; ;} break; - case 715: /* opt_include_nulls: INCLUDE_P NULLS_P */ + case 718: #line 1110 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = true; } -#line 24926 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = true; ;} break; - case 716: /* opt_include_nulls: EXCLUDE NULLS_P */ + case 719: #line 1111 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = false; } -#line 24932 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = false; ;} break; - case 717: /* opt_include_nulls: %empty */ + case 720: #line 1112 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = false; } -#line 24938 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = false; ;} break; - case 718: /* single_pivot_value: b_expr IN_P '(' target_list_opt_comma ')' */ + case 721: #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 24949 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 719: /* single_pivot_value: b_expr IN_P ColIdOrString */ + case 722: #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 24960 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 721: /* pivot_header: d_expr */ + case 724: #line 1133 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].node)); } -#line 24966 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 722: /* pivot_header: indirection_expr */ + case 725: #line 1134 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].node)); } -#line 24972 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 723: /* pivot_header: '(' c_expr_list_opt_comma ')' */ + case 726: #line 1135 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 24978 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 724: /* pivot_value: pivot_header IN_P '(' target_list_opt_comma ')' */ + case 727: #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 24989 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 725: /* pivot_value: pivot_header IN_P ColIdOrString */ + case 728: #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 25000 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 726: /* pivot_value_list: pivot_value */ + case 729: #line 1156 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = list_make1((yyvsp[0].node)); - } -#line 25008 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); + ;} break; - case 727: /* pivot_value_list: pivot_value_list pivot_value */ + case 730: #line 1160 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = lappend((yyvsp[-1].list), (yyvsp[0].node)); - } -#line 25016 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); + ;} break; - case 728: /* unpivot_header: ColIdOrString */ + case 731: #line 1166 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString((yyvsp[0].str))); } -#line 25022 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; - case 729: /* unpivot_header: '(' name_list_opt_comma ')' */ + case 732: #line 1167 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 25028 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 730: /* unpivot_value: unpivot_header IN_P '(' target_list_opt_comma ')' */ + case 733: #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 25039 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 731: /* unpivot_value_list: unpivot_value */ + case 734: #line 1181 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = list_make1((yyvsp[0].node)); - } -#line 25047 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); + ;} break; - case 732: /* unpivot_value_list: unpivot_value_list unpivot_value */ + case 735: #line 1185 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = lappend((yyvsp[-1].list), (yyvsp[0].node)); - } -#line 25055 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); + ;} break; - case 733: /* joined_table: '(' joined_table ')' */ + case 736: #line 1210 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.jexpr) = (yyvsp[-1].jexpr); - } -#line 25063 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.jexpr) = (yyvsp[(2) - (3)].jexpr); + ;} break; - case 734: /* joined_table: table_ref CROSS JOIN table_ref */ + case 737: #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 25080 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 735: /* joined_table: table_ref join_type JOIN table_ref join_qual */ + case 738: #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 25098 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 736: /* joined_table: table_ref JOIN table_ref join_qual */ + case 739: #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 25117 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 737: /* joined_table: table_ref NATURAL join_type JOIN table_ref */ + case 740: #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 25133 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 738: /* joined_table: table_ref NATURAL JOIN table_ref */ + case 741: #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 25150 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 739: /* joined_table: table_ref ASOF join_type JOIN table_ref join_qual */ + case 742: #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 25168 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 740: /* joined_table: table_ref ASOF JOIN table_ref join_qual */ + case 743: #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 25186 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 741: /* joined_table: table_ref POSITIONAL JOIN table_ref */ + case 744: #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 25203 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 742: /* joined_table: table_ref ANTI JOIN table_ref join_qual */ + case 745: #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 25222 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 743: /* joined_table: table_ref SEMI JOIN table_ref join_qual */ + case 746: #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 25242 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 744: /* alias_clause: AS ColIdOrString '(' name_list_opt_comma ')' */ + case 747: #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 25252 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.alias)->aliasname = (yyvsp[(2) - (5)].str); + (yyval.alias)->colnames = (yyvsp[(4) - (5)].list); + ;} break; - case 745: /* alias_clause: AS ColIdOrString */ + case 748: #line 1362 "third_party/libpg_query/grammar/statements/select.y" - { + { (yyval.alias) = makeNode(PGAlias); - (yyval.alias)->aliasname = (yyvsp[0].str); - } -#line 25261 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.alias)->aliasname = (yyvsp[(2) - (2)].str); + ;} break; - case 746: /* alias_clause: ColId '(' name_list_opt_comma ')' */ + case 749: #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 25271 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.alias)->aliasname = (yyvsp[(1) - (4)].str); + (yyval.alias)->colnames = (yyvsp[(3) - (4)].list); + ;} break; - case 747: /* alias_clause: ColId */ + case 750: #line 1373 "third_party/libpg_query/grammar/statements/select.y" - { + { (yyval.alias) = makeNode(PGAlias); - (yyval.alias)->aliasname = (yyvsp[0].str); - } -#line 25280 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.alias)->aliasname = (yyvsp[(1) - (1)].str); + ;} break; - case 748: /* opt_alias_clause: alias_clause */ + case 751: #line 1379 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.alias) = (yyvsp[0].alias); } -#line 25286 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.alias) = (yyvsp[(1) - (1)].alias); ;} break; - case 749: /* opt_alias_clause: %empty */ + case 752: #line 1380 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.alias) = NULL; } -#line 25292 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.alias) = NULL; ;} break; - case 750: /* func_alias_clause: alias_clause */ + case 753: #line 1389 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = list_make2((yyvsp[0].alias), NIL); - } -#line 25300 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = list_make2((yyvsp[(1) - (1)].alias), NIL); + ;} break; - case 751: /* func_alias_clause: AS '(' TableFuncElementList ')' */ + case 754: #line 1393 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = list_make2(NULL, (yyvsp[-1].list)); - } -#line 25308 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = list_make2(NULL, (yyvsp[(3) - (4)].list)); + ;} break; - case 752: /* func_alias_clause: AS ColIdOrString '(' TableFuncElementList ')' */ + case 755: #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 25318 "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 753: /* func_alias_clause: ColId '(' TableFuncElementList ')' */ + case 756: #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 25328 "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 754: /* func_alias_clause: %empty */ + case 757: #line 1409 "third_party/libpg_query/grammar/statements/select.y" - { + { (yyval.list) = list_make2(NULL, NIL); - } -#line 25336 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 755: /* join_type: FULL join_outer */ + case 758: #line 1414 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.jtype) = PG_JOIN_FULL; } -#line 25342 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.jtype) = PG_JOIN_FULL; ;} break; - case 756: /* join_type: LEFT join_outer */ + case 759: #line 1415 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.jtype) = PG_JOIN_LEFT; } -#line 25348 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.jtype) = PG_JOIN_LEFT; ;} break; - case 757: /* join_type: RIGHT join_outer */ + case 760: #line 1416 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.jtype) = PG_JOIN_RIGHT; } -#line 25354 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.jtype) = PG_JOIN_RIGHT; ;} break; - case 758: /* join_type: SEMI */ + case 761: #line 1417 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.jtype) = PG_JOIN_SEMI; } -#line 25360 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.jtype) = PG_JOIN_SEMI; ;} break; - case 759: /* join_type: ANTI */ + case 762: #line 1418 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.jtype) = PG_JOIN_ANTI; } -#line 25366 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.jtype) = PG_JOIN_ANTI; ;} break; - case 760: /* join_type: INNER_P */ + case 763: #line 1419 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.jtype) = PG_JOIN_INNER; } -#line 25372 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.jtype) = PG_JOIN_INNER; ;} break; - case 761: /* join_outer: OUTER_P */ + case 764: #line 1423 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = NULL; } -#line 25378 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = NULL; ;} break; - case 762: /* join_outer: %empty */ + case 765: #line 1424 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = NULL; } -#line 25384 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = NULL; ;} break; - case 763: /* join_qual: USING '(' name_list_opt_comma ')' */ + case 766: #line 1436 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) (yyvsp[-1].list); } -#line 25390 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) (yyvsp[(3) - (4)].list); ;} break; - case 764: /* join_qual: ON a_expr */ + case 767: #line 1437 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 25396 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 765: /* relation_expr: qualified_name */ + case 768: #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 25407 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 766: /* relation_expr: qualified_name '*' */ + case 769: #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 25418 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 767: /* relation_expr: ONLY qualified_name */ + case 770: #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 25429 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 768: /* relation_expr: ONLY '(' qualified_name ')' */ + case 771: #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 25440 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 769: /* func_table: func_expr_windowless opt_ordinality */ + case 772: #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 25455 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 770: /* func_table: ROWS FROM '(' rowsfrom_list ')' opt_ordinality */ + case 773: #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 25470 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 771: /* rowsfrom_item: func_expr_windowless opt_col_def_list */ + case 774: #line 1520 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make2((yyvsp[-1].node), (yyvsp[0].list)); } -#line 25476 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make2((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].list)); ;} break; - case 772: /* rowsfrom_list: rowsfrom_item */ + case 775: #line 1524 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].list)); } -#line 25482 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].list)); ;} break; - case 773: /* rowsfrom_list: rowsfrom_list ',' rowsfrom_item */ + case 776: #line 1525 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].list)); } -#line 25488 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); ;} break; - case 774: /* opt_col_def_list: AS '(' TableFuncElementList ')' */ + case 777: #line 1528 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 25494 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; - case 775: /* opt_col_def_list: %empty */ + case 778: #line 1529 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 25500 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 776: /* opt_ordinality: WITH_LA ORDINALITY */ + case 779: #line 1532 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = true; } -#line 25506 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = true; ;} break; - case 777: /* opt_ordinality: %empty */ + case 780: #line 1533 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = false; } -#line 25512 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = false; ;} break; - case 778: /* where_clause: WHERE a_expr */ + case 781: #line 1538 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 25518 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 779: /* where_clause: %empty */ + case 782: #line 1539 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = NULL; } -#line 25524 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = NULL; ;} break; - case 780: /* TableFuncElementList: TableFuncElement */ + case 783: #line 1545 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = list_make1((yyvsp[0].node)); - } -#line 25532 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); + ;} break; - case 781: /* TableFuncElementList: TableFuncElementList ',' TableFuncElement */ + case 784: #line 1549 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].node)); - } -#line 25540 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); + ;} break; - case 782: /* TableFuncElement: ColIdOrString Typename opt_collate_clause */ + case 785: #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; @@ -25552,470 +25887,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 25562 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 783: /* opt_collate_clause: COLLATE any_name */ + case 786: #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 25574 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 784: /* opt_collate_clause: %empty */ + case 787: #line 1583 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = NULL; } -#line 25580 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = NULL; ;} break; - case 785: /* colid_type_list: ColId Typename */ + case 788: #line 1596 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = list_make1(list_make2(makeString((yyvsp[-1].str)), (yyvsp[0].typnam))); - } -#line 25588 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = list_make1(list_make2(makeString((yyvsp[(1) - (2)].str)), (yyvsp[(2) - (2)].typnam))); + ;} break; - case 786: /* colid_type_list: colid_type_list ',' ColId Typename */ + case 789: #line 1599 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = lappend((yyvsp[-3].list), list_make2(makeString((yyvsp[-1].str)), (yyvsp[0].typnam))); - } -#line 25596 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = lappend((yyvsp[(1) - (4)].list), list_make2(makeString((yyvsp[(3) - (4)].str)), (yyvsp[(4) - (4)].typnam))); + ;} break; - case 789: /* opt_Typename: Typename */ + case 792: #line 1606 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.typnam) = (yyvsp[0].typnam); } -#line 25602 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 790: /* opt_Typename: %empty */ + case 793: #line 1607 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.typnam) = NULL; } -#line 25608 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.typnam) = NULL; ;} break; - case 791: /* Typename: SimpleTypename opt_array_bounds */ + case 794: #line 1610 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[-1].typnam); - (yyval.typnam)->arrayBounds = (yyvsp[0].list); - } -#line 25617 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.typnam) = (yyvsp[(1) - (2)].typnam); + (yyval.typnam)->arrayBounds = (yyvsp[(2) - (2)].list); + ;} break; - case 792: /* Typename: SETOF SimpleTypename opt_array_bounds */ + case 795: #line 1615 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[-1].typnam); - (yyval.typnam)->arrayBounds = (yyvsp[0].list); + { + (yyval.typnam) = (yyvsp[(2) - (3)].typnam); + (yyval.typnam)->arrayBounds = (yyvsp[(3) - (3)].list); (yyval.typnam)->setof = true; - } -#line 25627 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 793: /* Typename: SimpleTypename ARRAY '[' Iconst ']' */ + case 796: #line 1622 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[-4].typnam); - (yyval.typnam)->arrayBounds = list_make1(makeInteger((yyvsp[-1].ival))); - } -#line 25636 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.typnam) = (yyvsp[(1) - (5)].typnam); + (yyval.typnam)->arrayBounds = list_make1(makeInteger((yyvsp[(4) - (5)].ival))); + ;} break; - case 794: /* Typename: SETOF SimpleTypename ARRAY '[' Iconst ']' */ + case 797: #line 1627 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[-4].typnam); - (yyval.typnam)->arrayBounds = list_make1(makeInteger((yyvsp[-1].ival))); + { + (yyval.typnam) = (yyvsp[(2) - (6)].typnam); + (yyval.typnam)->arrayBounds = list_make1(makeInteger((yyvsp[(5) - (6)].ival))); (yyval.typnam)->setof = true; - } -#line 25646 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 795: /* Typename: SimpleTypename ARRAY */ + case 798: #line 1633 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[-1].typnam); + { + (yyval.typnam) = (yyvsp[(1) - (2)].typnam); (yyval.typnam)->arrayBounds = list_make1(makeInteger(-1)); - } -#line 25655 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 796: /* Typename: SETOF SimpleTypename ARRAY */ + case 799: #line 1638 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[-1].typnam); + { + (yyval.typnam) = (yyvsp[(2) - (3)].typnam); (yyval.typnam)->arrayBounds = list_make1(makeInteger(-1)); (yyval.typnam)->setof = true; - } -#line 25665 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 797: /* Typename: qualified_typename */ + case 800: #line 1644 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = makeTypeNameFromNameList((yyvsp[0].list)); - } -#line 25673 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.typnam) = makeTypeNameFromNameList((yyvsp[(1) - (1)].list)); + ;} break; - case 798: /* Typename: RowOrStruct '(' colid_type_list ')' opt_array_bounds */ + case 801: #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 25684 "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 799: /* Typename: MAP '(' type_list ')' opt_array_bounds */ + case 802: #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 25695 "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 800: /* Typename: UNION '(' colid_type_list ')' opt_array_bounds */ + case 803: #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 25706 "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 801: /* qualified_typename: IDENT '.' IDENT */ + case 804: #line 1671 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make2(makeString((yyvsp[-2].str)), makeString((yyvsp[0].str))); } -#line 25712 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make2(makeString((yyvsp[(1) - (3)].str)), makeString((yyvsp[(3) - (3)].str))); ;} break; - case 802: /* qualified_typename: qualified_typename '.' IDENT */ + case 805: #line 1672 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), makeString((yyvsp[0].str))); } -#line 25718 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), makeString((yyvsp[(3) - (3)].str))); ;} break; - case 803: /* opt_array_bounds: opt_array_bounds '[' ']' */ + case 806: #line 1677 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), makeInteger(-1)); } -#line 25724 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), makeInteger(-1)); ;} break; - case 804: /* opt_array_bounds: opt_array_bounds '[' Iconst ']' */ + case 807: #line 1679 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-3].list), makeInteger((yyvsp[-1].ival))); } -#line 25730 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (4)].list), makeInteger((yyvsp[(3) - (4)].ival))); ;} break; - case 805: /* opt_array_bounds: %empty */ + case 808: #line 1681 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 25736 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 806: /* SimpleTypename: GenericType */ + case 809: #line 1685 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.typnam) = (yyvsp[0].typnam); } -#line 25742 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 807: /* SimpleTypename: Numeric */ + case 810: #line 1686 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.typnam) = (yyvsp[0].typnam); } -#line 25748 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 808: /* SimpleTypename: Bit */ + case 811: #line 1687 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.typnam) = (yyvsp[0].typnam); } -#line 25754 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 809: /* SimpleTypename: Character */ + case 812: #line 1688 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.typnam) = (yyvsp[0].typnam); } -#line 25760 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 810: /* SimpleTypename: ConstDatetime */ + case 813: #line 1689 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.typnam) = (yyvsp[0].typnam); } -#line 25766 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 811: /* SimpleTypename: ConstInterval opt_interval */ + case 814: #line 1691 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[-1].typnam); - (yyval.typnam)->typmods = (yyvsp[0].list); - } -#line 25775 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.typnam) = (yyvsp[(1) - (2)].typnam); + (yyval.typnam)->typmods = (yyvsp[(2) - (2)].list); + ;} break; - case 812: /* SimpleTypename: ConstInterval '(' Iconst ')' */ + case 815: #line 1696 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[-3].typnam); + { + (yyval.typnam) = (yyvsp[(1) - (4)].typnam); (yyval.typnam)->typmods = list_make2(makeIntConst(INTERVAL_FULL_RANGE, -1), - makeIntConst((yyvsp[-1].ival), (yylsp[-1]))); - } -#line 25785 "third_party/libpg_query/grammar/grammar_out.cpp" + makeIntConst((yyvsp[(3) - (4)].ival), (yylsp[(3) - (4)]))); + ;} break; - case 813: /* ConstTypename: Numeric */ + case 816: #line 1715 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.typnam) = (yyvsp[0].typnam); } -#line 25791 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 814: /* ConstTypename: ConstBit */ + case 817: #line 1716 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.typnam) = (yyvsp[0].typnam); } -#line 25797 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 815: /* ConstTypename: ConstCharacter */ + case 818: #line 1717 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.typnam) = (yyvsp[0].typnam); } -#line 25803 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 816: /* ConstTypename: ConstDatetime */ + case 819: #line 1718 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.typnam) = (yyvsp[0].typnam); } -#line 25809 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 817: /* GenericType: type_name_token opt_type_modifiers */ + case 820: #line 1730 "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 25819 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.typnam) = makeTypeName((yyvsp[(1) - (2)].str)); + (yyval.typnam)->typmods = (yyvsp[(2) - (2)].list); + (yyval.typnam)->location = (yylsp[(1) - (2)]); + ;} break; - case 818: /* opt_type_modifiers: '(' opt_expr_list_opt_comma ')' */ + case 821: #line 1743 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 25825 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 819: /* opt_type_modifiers: %empty */ + case 822: #line 1744 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 25831 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 820: /* Numeric: INT_P */ + case 823: #line 1751 "third_party/libpg_query/grammar/statements/select.y" - { + { (yyval.typnam) = SystemTypeName("int4"); - (yyval.typnam)->location = (yylsp[0]); - } -#line 25840 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->location = (yylsp[(1) - (1)]); + ;} break; - case 821: /* Numeric: INTEGER */ + case 824: #line 1756 "third_party/libpg_query/grammar/statements/select.y" - { + { (yyval.typnam) = SystemTypeName("int4"); - (yyval.typnam)->location = (yylsp[0]); - } -#line 25849 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->location = (yylsp[(1) - (1)]); + ;} break; - case 822: /* Numeric: SMALLINT */ + case 825: #line 1761 "third_party/libpg_query/grammar/statements/select.y" - { + { (yyval.typnam) = SystemTypeName("int2"); - (yyval.typnam)->location = (yylsp[0]); - } -#line 25858 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->location = (yylsp[(1) - (1)]); + ;} break; - case 823: /* Numeric: BIGINT */ + case 826: #line 1766 "third_party/libpg_query/grammar/statements/select.y" - { + { (yyval.typnam) = SystemTypeName("int8"); - (yyval.typnam)->location = (yylsp[0]); - } -#line 25867 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->location = (yylsp[(1) - (1)]); + ;} break; - case 824: /* Numeric: REAL */ + case 827: #line 1771 "third_party/libpg_query/grammar/statements/select.y" - { + { (yyval.typnam) = SystemTypeName("float4"); - (yyval.typnam)->location = (yylsp[0]); - } -#line 25876 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->location = (yylsp[(1) - (1)]); + ;} break; - case 825: /* Numeric: FLOAT_P opt_float */ + case 828: #line 1776 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[0].typnam); - (yyval.typnam)->location = (yylsp[-1]); - } -#line 25885 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.typnam) = (yyvsp[(2) - (2)].typnam); + (yyval.typnam)->location = (yylsp[(1) - (2)]); + ;} break; - case 826: /* Numeric: DOUBLE_P PRECISION */ + case 829: #line 1781 "third_party/libpg_query/grammar/statements/select.y" - { + { (yyval.typnam) = SystemTypeName("float8"); - (yyval.typnam)->location = (yylsp[-1]); - } -#line 25894 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->location = (yylsp[(1) - (2)]); + ;} break; - case 827: /* Numeric: DECIMAL_P opt_type_modifiers */ + case 830: #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 25904 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->typmods = (yyvsp[(2) - (2)].list); + (yyval.typnam)->location = (yylsp[(1) - (2)]); + ;} break; - case 828: /* Numeric: DEC opt_type_modifiers */ + case 831: #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 25914 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->typmods = (yyvsp[(2) - (2)].list); + (yyval.typnam)->location = (yylsp[(1) - (2)]); + ;} break; - case 829: /* Numeric: NUMERIC opt_type_modifiers */ + case 832: #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 25924 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->typmods = (yyvsp[(2) - (2)].list); + (yyval.typnam)->location = (yylsp[(1) - (2)]); + ;} break; - case 830: /* Numeric: BOOLEAN_P */ + case 833: #line 1804 "third_party/libpg_query/grammar/statements/select.y" - { + { (yyval.typnam) = SystemTypeName("bool"); - (yyval.typnam)->location = (yylsp[0]); - } -#line 25933 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->location = (yylsp[(1) - (1)]); + ;} break; - case 831: /* opt_float: '(' Iconst ')' */ + case 834: #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 25958 "third_party/libpg_query/grammar/grammar_out.cpp" + parser_errposition((yylsp[(2) - (3)])))); + ;} break; - case 832: /* opt_float: %empty */ + case 835: #line 1832 "third_party/libpg_query/grammar/statements/select.y" - { + { (yyval.typnam) = SystemTypeName("float4"); - } -#line 25966 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 833: /* Bit: BitWithLength */ + case 836: #line 1842 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[0].typnam); - } -#line 25974 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.typnam) = (yyvsp[(1) - (1)].typnam); + ;} break; - case 834: /* Bit: BitWithoutLength */ + case 837: #line 1846 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[0].typnam); - } -#line 25982 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.typnam) = (yyvsp[(1) - (1)].typnam); + ;} break; - case 835: /* ConstBit: BitWithLength */ + case 838: #line 1854 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[0].typnam); - } -#line 25990 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.typnam) = (yyvsp[(1) - (1)].typnam); + ;} break; - case 836: /* ConstBit: BitWithoutLength */ + case 839: #line 1858 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[0].typnam); + { + (yyval.typnam) = (yyvsp[(1) - (1)].typnam); (yyval.typnam)->typmods = NIL; - } -#line 25999 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 837: /* BitWithLength: BIT opt_varying '(' expr_list_opt_comma ')' */ + case 840: #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 26012 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->typmods = (yyvsp[(4) - (5)].list); + (yyval.typnam)->location = (yylsp[(1) - (5)]); + ;} break; - case 838: /* BitWithoutLength: BIT opt_varying */ + case 841: #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"); } @@ -26024,988 +26305,878 @@ YYLTYPE yylloc = yyloc_default; (yyval.typnam) = SystemTypeName("bit"); (yyval.typnam)->typmods = list_make1(makeIntConst(1, -1)); } - (yyval.typnam)->location = (yylsp[-1]); - } -#line 26030 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->location = (yylsp[(1) - (2)]); + ;} break; - case 839: /* Character: CharacterWithLength */ + case 842: #line 1899 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[0].typnam); - } -#line 26038 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.typnam) = (yyvsp[(1) - (1)].typnam); + ;} break; - case 840: /* Character: CharacterWithoutLength */ + case 843: #line 1903 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[0].typnam); - } -#line 26046 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.typnam) = (yyvsp[(1) - (1)].typnam); + ;} break; - case 841: /* ConstCharacter: CharacterWithLength */ + case 844: #line 1909 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = (yyvsp[0].typnam); - } -#line 26054 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.typnam) = (yyvsp[(1) - (1)].typnam); + ;} break; - case 842: /* ConstCharacter: CharacterWithoutLength */ + case 845: #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 26069 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 843: /* CharacterWithLength: character '(' Iconst ')' */ + case 846: #line 1926 "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 26079 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (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 844: /* CharacterWithoutLength: character */ + case 847: #line 1934 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.typnam) = SystemTypeName((yyvsp[0].conststr)); + { + (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 26091 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->location = (yylsp[(1) - (1)]); + ;} break; - case 845: /* character: CHARACTER opt_varying */ + case 848: #line 1944 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = (yyvsp[0].boolean) ? "varchar": "bpchar"; } -#line 26097 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.conststr) = (yyvsp[(2) - (2)].boolean) ? "varchar": "bpchar"; ;} break; - case 846: /* character: CHAR_P opt_varying */ + case 849: #line 1946 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = (yyvsp[0].boolean) ? "varchar": "bpchar"; } -#line 26103 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.conststr) = (yyvsp[(2) - (2)].boolean) ? "varchar": "bpchar"; ;} break; - case 847: /* character: VARCHAR */ + case 850: #line 1948 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = "varchar"; } -#line 26109 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.conststr) = "varchar"; ;} break; - case 848: /* character: NATIONAL CHARACTER opt_varying */ + case 851: #line 1950 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = (yyvsp[0].boolean) ? "varchar": "bpchar"; } -#line 26115 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.conststr) = (yyvsp[(3) - (3)].boolean) ? "varchar": "bpchar"; ;} break; - case 849: /* character: NATIONAL CHAR_P opt_varying */ + case 852: #line 1952 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = (yyvsp[0].boolean) ? "varchar": "bpchar"; } -#line 26121 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.conststr) = (yyvsp[(3) - (3)].boolean) ? "varchar": "bpchar"; ;} break; - case 850: /* character: NCHAR opt_varying */ + case 853: #line 1954 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = (yyvsp[0].boolean) ? "varchar": "bpchar"; } -#line 26127 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.conststr) = (yyvsp[(2) - (2)].boolean) ? "varchar": "bpchar"; ;} break; - case 851: /* opt_varying: VARYING */ + case 854: #line 1958 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = true; } -#line 26133 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = true; ;} break; - case 852: /* opt_varying: %empty */ + case 855: #line 1959 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = false; } -#line 26139 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = false; ;} break; - case 853: /* ConstDatetime: TIMESTAMP '(' Iconst ')' opt_timezone */ + case 856: #line 1967 "third_party/libpg_query/grammar/statements/select.y" - { - if ((yyvsp[0].boolean)) + { + 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 26152 "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 854: /* ConstDatetime: TIMESTAMP opt_timezone */ + case 857: #line 1976 "third_party/libpg_query/grammar/statements/select.y" - { - if ((yyvsp[0].boolean)) + { + if ((yyvsp[(2) - (2)].boolean)) (yyval.typnam) = SystemTypeName("timestamptz"); else (yyval.typnam) = SystemTypeName("timestamp"); - (yyval.typnam)->location = (yylsp[-1]); - } -#line 26164 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->location = (yylsp[(1) - (2)]); + ;} break; - case 855: /* ConstDatetime: TIME '(' Iconst ')' opt_timezone */ + case 858: #line 1984 "third_party/libpg_query/grammar/statements/select.y" - { - if ((yyvsp[0].boolean)) + { + 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 26177 "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 856: /* ConstDatetime: TIME opt_timezone */ + case 859: #line 1993 "third_party/libpg_query/grammar/statements/select.y" - { - if ((yyvsp[0].boolean)) + { + if ((yyvsp[(2) - (2)].boolean)) (yyval.typnam) = SystemTypeName("timetz"); else (yyval.typnam) = SystemTypeName("time"); - (yyval.typnam)->location = (yylsp[-1]); - } -#line 26189 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->location = (yylsp[(1) - (2)]); + ;} break; - case 857: /* ConstInterval: INTERVAL */ + case 860: #line 2004 "third_party/libpg_query/grammar/statements/select.y" - { + { (yyval.typnam) = SystemTypeName("interval"); - (yyval.typnam)->location = (yylsp[0]); - } -#line 26198 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.typnam)->location = (yylsp[(1) - (1)]); + ;} break; - case 858: /* opt_timezone: WITH_LA TIME ZONE */ + case 861: #line 2011 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = true; } -#line 26204 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = true; ;} break; - case 859: /* opt_timezone: WITHOUT TIME ZONE */ + case 862: #line 2012 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = false; } -#line 26210 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = false; ;} break; - case 860: /* opt_timezone: %empty */ + case 863: #line 2013 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = false; } -#line 26216 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = false; ;} break; - case 887: /* opt_interval: year_keyword */ + case 890: #line 2057 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(YEAR), (yylsp[0]))); } -#line 26222 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(YEAR), (yylsp[(1) - (1)]))); ;} break; - case 888: /* opt_interval: month_keyword */ + case 891: #line 2059 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MONTH), (yylsp[0]))); } -#line 26228 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MONTH), (yylsp[(1) - (1)]))); ;} break; - case 889: /* opt_interval: day_keyword */ + case 892: #line 2061 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(DAY), (yylsp[0]))); } -#line 26234 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(DAY), (yylsp[(1) - (1)]))); ;} break; - case 890: /* opt_interval: hour_keyword */ + case 893: #line 2063 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(HOUR), (yylsp[0]))); } -#line 26240 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(HOUR), (yylsp[(1) - (1)]))); ;} break; - case 891: /* opt_interval: minute_keyword */ + case 894: #line 2065 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MINUTE), (yylsp[0]))); } -#line 26246 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MINUTE), (yylsp[(1) - (1)]))); ;} break; - case 892: /* opt_interval: second_keyword */ + case 895: #line 2067 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(SECOND), (yylsp[0]))); } -#line 26252 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(SECOND), (yylsp[(1) - (1)]))); ;} break; - case 893: /* opt_interval: millisecond_keyword */ + case 896: #line 2069 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MILLISECOND), (yylsp[0]))); } -#line 26258 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MILLISECOND), (yylsp[(1) - (1)]))); ;} break; - case 894: /* opt_interval: microsecond_keyword */ + case 897: #line 2071 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MICROSECOND), (yylsp[0]))); } -#line 26264 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MICROSECOND), (yylsp[(1) - (1)]))); ;} break; - case 895: /* opt_interval: week_keyword */ + case 898: #line 2073 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(WEEK), (yylsp[0]))); } -#line 26270 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(WEEK), (yylsp[(1) - (1)]))); ;} break; - case 896: /* opt_interval: quarter_keyword */ + case 899: #line 2075 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(QUARTER), (yylsp[0]))); } -#line 26276 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(QUARTER), (yylsp[(1) - (1)]))); ;} break; - case 897: /* opt_interval: decade_keyword */ + case 900: #line 2077 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(DECADE), (yylsp[0]))); } -#line 26282 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(DECADE), (yylsp[(1) - (1)]))); ;} break; - case 898: /* opt_interval: century_keyword */ + case 901: #line 2079 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(CENTURY), (yylsp[0]))); } -#line 26288 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(CENTURY), (yylsp[(1) - (1)]))); ;} break; - case 899: /* opt_interval: millennium_keyword */ + case 902: #line 2081 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MILLENNIUM), (yylsp[0]))); } -#line 26294 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MILLENNIUM), (yylsp[(1) - (1)]))); ;} break; - case 900: /* opt_interval: year_keyword TO month_keyword */ + case 903: #line 2083 "third_party/libpg_query/grammar/statements/select.y" - { + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(YEAR) | - INTERVAL_MASK(MONTH), (yylsp[-2]))); - } -#line 26303 "third_party/libpg_query/grammar/grammar_out.cpp" + INTERVAL_MASK(MONTH), (yylsp[(1) - (3)]))); + ;} break; - case 901: /* opt_interval: day_keyword TO hour_keyword */ + case 904: #line 2088 "third_party/libpg_query/grammar/statements/select.y" - { + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(DAY) | - INTERVAL_MASK(HOUR), (yylsp[-2]))); - } -#line 26312 "third_party/libpg_query/grammar/grammar_out.cpp" + INTERVAL_MASK(HOUR), (yylsp[(1) - (3)]))); + ;} break; - case 902: /* opt_interval: day_keyword TO minute_keyword */ + case 905: #line 2093 "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 26322 "third_party/libpg_query/grammar/grammar_out.cpp" + INTERVAL_MASK(MINUTE), (yylsp[(1) - (3)]))); + ;} break; - case 903: /* opt_interval: day_keyword TO second_keyword */ + case 906: #line 2099 "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 26333 "third_party/libpg_query/grammar/grammar_out.cpp" + INTERVAL_MASK(SECOND), (yylsp[(1) - (3)]))); + ;} break; - case 904: /* opt_interval: hour_keyword TO minute_keyword */ + case 907: #line 2106 "third_party/libpg_query/grammar/statements/select.y" - { + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(HOUR) | - INTERVAL_MASK(MINUTE), (yylsp[-2]))); - } -#line 26342 "third_party/libpg_query/grammar/grammar_out.cpp" + INTERVAL_MASK(MINUTE), (yylsp[(1) - (3)]))); + ;} break; - case 905: /* opt_interval: hour_keyword TO second_keyword */ + case 908: #line 2111 "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 26352 "third_party/libpg_query/grammar/grammar_out.cpp" + INTERVAL_MASK(SECOND), (yylsp[(1) - (3)]))); + ;} break; - case 906: /* opt_interval: minute_keyword TO second_keyword */ + case 909: #line 2117 "third_party/libpg_query/grammar/statements/select.y" - { + { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MINUTE) | - INTERVAL_MASK(SECOND), (yylsp[-2]))); - } -#line 26361 "third_party/libpg_query/grammar/grammar_out.cpp" + INTERVAL_MASK(SECOND), (yylsp[(1) - (3)]))); + ;} break; - case 907: /* opt_interval: %empty */ + case 910: #line 2122 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 26367 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 908: /* a_expr: c_expr */ + case 911: #line 2153 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 26373 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 909: /* a_expr: a_expr TYPECAST Typename */ + case 912: #line 2156 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = makeTypeCast((yyvsp[-2].node), (yyvsp[0].typnam), 0, (yylsp[-1])); } -#line 26379 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = makeTypeCast((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].typnam), 0, (yylsp[(2) - (3)])); ;} break; - case 910: /* a_expr: a_expr COLLATE any_name */ + case 913: #line 2158 "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 26391 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 911: /* a_expr: a_expr AT TIME ZONE a_expr */ + case 914: #line 2166 "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 26401 "third_party/libpg_query/grammar/grammar_out.cpp" + list_make2((yyvsp[(5) - (5)].node), (yyvsp[(1) - (5)].node)), + (yylsp[(2) - (5)])); + ;} break; - case 912: /* a_expr: '+' a_expr */ + case 915: #line 2181 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", NULL, (yyvsp[0].node), (yylsp[-1])); } -#line 26407 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", NULL, (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 913: /* a_expr: '-' a_expr */ + case 916: #line 2183 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = doNegate((yyvsp[0].node), (yylsp[-1])); } -#line 26413 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = doNegate((yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 914: /* a_expr: a_expr '+' a_expr */ + case 917: #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 26419 "third_party/libpg_query/grammar/grammar_out.cpp" + { (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 */ + case 918: #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 26425 "third_party/libpg_query/grammar/grammar_out.cpp" + { (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 */ + case 919: #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 26431 "third_party/libpg_query/grammar/grammar_out.cpp" + { (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 '/' a_expr */ + case 920: #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 26437 "third_party/libpg_query/grammar/grammar_out.cpp" + { (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 INTEGER_DIVISION a_expr */ + case 921: #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 26443 "third_party/libpg_query/grammar/grammar_out.cpp" + { (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 '%' a_expr */ + case 922: #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 26449 "third_party/libpg_query/grammar/grammar_out.cpp" + { (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 '^' a_expr */ + case 923: #line 2197 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "^", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26455 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "^", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 921: /* a_expr: a_expr POWER_OF a_expr */ + case 924: #line 2199 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "**", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26461 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "**", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 922: /* a_expr: a_expr '<' a_expr */ + case 925: #line 2201 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26467 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 923: /* a_expr: a_expr '>' a_expr */ + case 926: #line 2203 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, ">", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26473 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, ">", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 924: /* a_expr: a_expr '=' a_expr */ + case 927: #line 2205 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "=", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26479 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 925: /* a_expr: a_expr LESS_EQUALS a_expr */ + case 928: #line 2207 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<=", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26485 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 926: /* a_expr: a_expr GREATER_EQUALS a_expr */ + case 929: #line 2209 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, ">=", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26491 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, ">=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 927: /* a_expr: a_expr NOT_EQUALS a_expr */ + case 930: #line 2211 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<>", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26497 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<>", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 928: /* a_expr: a_expr qual_Op a_expr */ + case 931: #line 2214 "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 26503 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[(2) - (3)].list), (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 929: /* a_expr: qual_Op a_expr */ + case 932: #line 2216 "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 26509 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[(1) - (2)].list), NULL, (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 930: /* a_expr: a_expr qual_Op */ + case 933: #line 2218 "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 26515 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[(2) - (2)].list), (yyvsp[(1) - (2)].node), NULL, (yylsp[(2) - (2)])); ;} break; - case 931: /* a_expr: a_expr AND a_expr */ + case 934: #line 2221 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = makeAndExpr((yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26521 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = makeAndExpr((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 932: /* a_expr: a_expr OR a_expr */ + case 935: #line 2223 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = makeOrExpr((yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 26527 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = makeOrExpr((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 933: /* a_expr: NOT a_expr */ + case 936: #line 2225 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = makeNotExpr((yyvsp[0].node), (yylsp[-1])); } -#line 26533 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = makeNotExpr((yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 934: /* a_expr: NOT_LA a_expr */ + case 937: #line 2227 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = makeNotExpr((yyvsp[0].node), (yylsp[-1])); } -#line 26539 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = makeNotExpr((yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 935: /* a_expr: a_expr GLOB a_expr */ + case 938: #line 2229 "third_party/libpg_query/grammar/statements/select.y" - { + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_GLOB, "~~~", - (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); - } -#line 26548 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); + ;} break; - case 936: /* a_expr: a_expr LIKE a_expr */ + case 939: #line 2234 "third_party/libpg_query/grammar/statements/select.y" - { + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_LIKE, "~~", - (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); - } -#line 26557 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); + ;} break; - case 937: /* a_expr: a_expr LIKE a_expr ESCAPE a_expr */ + case 940: #line 2239 "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 26568 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 938: /* a_expr: a_expr NOT_LA LIKE a_expr */ + case 941: #line 2246 "third_party/libpg_query/grammar/statements/select.y" - { + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_LIKE, "!~~", - (yyvsp[-3].node), (yyvsp[0].node), (yylsp[-2])); - } -#line 26577 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node), (yylsp[(2) - (4)])); + ;} break; - case 939: /* a_expr: a_expr NOT_LA LIKE a_expr ESCAPE a_expr */ + case 942: #line 2251 "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 26588 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 940: /* a_expr: a_expr ILIKE a_expr */ + case 943: #line 2258 "third_party/libpg_query/grammar/statements/select.y" - { + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_ILIKE, "~~*", - (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); - } -#line 26597 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); + ;} break; - case 941: /* a_expr: a_expr ILIKE a_expr ESCAPE a_expr */ + case 944: #line 2263 "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 26608 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 942: /* a_expr: a_expr NOT_LA ILIKE a_expr */ + case 945: #line 2270 "third_party/libpg_query/grammar/statements/select.y" - { + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_ILIKE, "!~~*", - (yyvsp[-3].node), (yyvsp[0].node), (yylsp[-2])); - } -#line 26617 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node), (yylsp[(2) - (4)])); + ;} break; - case 943: /* a_expr: a_expr NOT_LA ILIKE a_expr ESCAPE a_expr */ + case 946: #line 2275 "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 26628 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 944: /* a_expr: a_expr SIMILAR TO a_expr */ + case 947: #line 2283 "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 26640 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyvsp[(1) - (4)].node), (PGNode *) n, (yylsp[(2) - (4)])); + ;} break; - case 945: /* a_expr: a_expr SIMILAR TO a_expr ESCAPE a_expr */ + case 948: #line 2291 "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 26652 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyvsp[(1) - (6)].node), (PGNode *) n, (yylsp[(2) - (6)])); + ;} break; - case 946: /* a_expr: a_expr NOT_LA SIMILAR TO a_expr */ + case 949: #line 2299 "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 26664 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyvsp[(1) - (5)].node), (PGNode *) n, (yylsp[(2) - (5)])); + ;} break; - case 947: /* a_expr: a_expr NOT_LA SIMILAR TO a_expr ESCAPE a_expr */ + case 950: #line 2307 "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 26676 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyvsp[(1) - (7)].node), (PGNode *) n, (yylsp[(2) - (7)])); + ;} break; - case 948: /* a_expr: a_expr IS NULL_P */ + case 951: #line 2325 "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 26688 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 949: /* a_expr: a_expr ISNULL */ + case 952: #line 2333 "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 26700 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 950: /* a_expr: a_expr IS NOT NULL_P */ + case 953: #line 2341 "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 26712 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 951: /* a_expr: a_expr NOT NULL_P */ + case 954: #line 2349 "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 26724 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 952: /* a_expr: a_expr NOTNULL */ + case 955: #line 2357 "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 26736 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 953: /* a_expr: a_expr LAMBDA_ARROW a_expr */ + case 956: #line 2365 "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 26748 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 954: /* a_expr: a_expr DOUBLE_ARROW a_expr */ + case 957: #line 2373 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "->>", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); - } -#line 26756 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "->>", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); + ;} break; - case 955: /* a_expr: row OVERLAPS row */ + case 958: #line 2377 "third_party/libpg_query/grammar/statements/select.y" - { - if (list_length((yyvsp[-2].list)) != 2) + { + 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 26776 "third_party/libpg_query/grammar/grammar_out.cpp" + list_concat((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)), + (yylsp[(2) - (3)])); + ;} break; - case 956: /* a_expr: a_expr IS TRUE_P */ + case 959: #line 2393 "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 26788 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 957: /* a_expr: a_expr IS NOT TRUE_P */ + case 960: #line 2401 "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 26800 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 958: /* a_expr: a_expr IS FALSE_P */ + case 961: #line 2409 "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 26812 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 959: /* a_expr: a_expr IS NOT FALSE_P */ + case 962: #line 2417 "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 26824 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 960: /* a_expr: a_expr IS UNKNOWN */ + case 963: #line 2425 "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 26836 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 961: /* a_expr: a_expr IS NOT UNKNOWN */ + case 964: #line 2433 "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 26848 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 962: /* a_expr: a_expr IS DISTINCT FROM a_expr */ + case 965: #line 2441 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_DISTINCT, "=", (yyvsp[-4].node), (yyvsp[0].node), (yylsp[-3])); - } -#line 26856 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_DISTINCT, "=", (yyvsp[(1) - (5)].node), (yyvsp[(5) - (5)].node), (yylsp[(2) - (5)])); + ;} break; - case 963: /* a_expr: a_expr IS NOT DISTINCT FROM a_expr */ + case 966: #line 2445 "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 26864 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_NOT_DISTINCT, "=", (yyvsp[(1) - (6)].node), (yyvsp[(6) - (6)].node), (yylsp[(2) - (6)])); + ;} break; - case 964: /* a_expr: a_expr IS OF '(' type_list ')' */ + case 967: #line 2449 "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 26872 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OF, "=", (yyvsp[(1) - (6)].node), (PGNode *) (yyvsp[(5) - (6)].list), (yylsp[(2) - (6)])); + ;} break; - case 965: /* a_expr: a_expr IS NOT OF '(' type_list ')' */ + case 968: #line 2453 "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 26880 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OF, "<>", (yyvsp[(1) - (7)].node), (PGNode *) (yyvsp[(6) - (7)].list), (yylsp[(2) - (7)])); + ;} break; - case 966: /* a_expr: a_expr BETWEEN opt_asymmetric b_expr AND a_expr */ + case 969: #line 2457 "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 26892 "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 967: /* a_expr: a_expr NOT_LA BETWEEN opt_asymmetric b_expr AND a_expr */ + case 970: #line 2465 "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 26904 "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 968: /* a_expr: a_expr BETWEEN SYMMETRIC b_expr AND a_expr */ + case 971: #line 2473 "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 26916 "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 969: /* a_expr: a_expr NOT_LA BETWEEN SYMMETRIC b_expr AND a_expr */ + case 972: #line 2481 "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 26928 "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 970: /* a_expr: a_expr IN_P in_expr */ + case 973: #line 2489 "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 26952 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 971: /* a_expr: a_expr NOT_LA IN_P in_expr */ + case 974: #line 2509 "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 26978 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 972: /* a_expr: a_expr subquery_Op sub_type select_with_parens */ + case 975: #line 2531 "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 26993 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 973: /* a_expr: a_expr subquery_Op sub_type '(' a_expr ')' */ + case 976: #line 2542 "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])); + { + 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 27004 "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 974: /* a_expr: DEFAULT */ + case 977: #line 2549 "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 @@ -27015,253 +27186,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 27022 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 975: /* a_expr: COLUMNS '(' a_expr ')' */ + case 978: #line 2563 "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 27034 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 976: /* a_expr: '*' opt_except_list opt_replace_list */ + case 979: #line 2571 "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 27046 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 977: /* a_expr: ColId '.' '*' opt_except_list opt_replace_list */ + case 980: #line 2579 "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 27059 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 978: /* b_expr: c_expr */ + case 981: #line 2599 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 27065 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 979: /* b_expr: b_expr TYPECAST Typename */ + case 982: #line 2601 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = makeTypeCast((yyvsp[-2].node), (yyvsp[0].typnam), 0, (yylsp[-1])); } -#line 27071 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = makeTypeCast((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].typnam), 0, (yylsp[(2) - (3)])); ;} break; - case 980: /* b_expr: '+' b_expr */ + case 983: #line 2603 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", NULL, (yyvsp[0].node), (yylsp[-1])); } -#line 27077 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", NULL, (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 981: /* b_expr: '-' b_expr */ + case 984: #line 2605 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = doNegate((yyvsp[0].node), (yylsp[-1])); } -#line 27083 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = doNegate((yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 982: /* b_expr: b_expr '+' b_expr */ + case 985: #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 27089 "third_party/libpg_query/grammar/grammar_out.cpp" + { (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 */ + case 986: #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 27095 "third_party/libpg_query/grammar/grammar_out.cpp" + { (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 */ + case 987: #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 27101 "third_party/libpg_query/grammar/grammar_out.cpp" + { (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 '/' b_expr */ + case 988: #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 27107 "third_party/libpg_query/grammar/grammar_out.cpp" + { (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 INTEGER_DIVISION b_expr */ + case 989: #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 27113 "third_party/libpg_query/grammar/grammar_out.cpp" + { (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 '%' b_expr */ + case 990: #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 27119 "third_party/libpg_query/grammar/grammar_out.cpp" + { (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 '^' b_expr */ + case 991: #line 2619 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "^", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 27125 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "^", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 989: /* b_expr: b_expr POWER_OF b_expr */ + case 992: #line 2621 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "**", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 27131 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "**", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 990: /* b_expr: b_expr '<' b_expr */ + case 993: #line 2623 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 27137 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 991: /* b_expr: b_expr '>' b_expr */ + case 994: #line 2625 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, ">", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 27143 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, ">", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 992: /* b_expr: b_expr '=' b_expr */ + case 995: #line 2627 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "=", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 27149 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 993: /* b_expr: b_expr LESS_EQUALS b_expr */ + case 996: #line 2629 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<=", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 27155 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 994: /* b_expr: b_expr GREATER_EQUALS b_expr */ + case 997: #line 2631 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, ">=", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 27161 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, ">=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 995: /* b_expr: b_expr NOT_EQUALS b_expr */ + case 998: #line 2633 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<>", (yyvsp[-2].node), (yyvsp[0].node), (yylsp[-1])); } -#line 27167 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<>", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 996: /* b_expr: b_expr qual_Op b_expr */ + case 999: #line 2635 "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 27173 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[(2) - (3)].list), (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 997: /* b_expr: qual_Op b_expr */ + case 1000: #line 2637 "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 27179 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[(1) - (2)].list), NULL, (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 998: /* b_expr: b_expr qual_Op */ + case 1001: #line 2639 "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 27185 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[(2) - (2)].list), (yyvsp[(1) - (2)].node), NULL, (yylsp[(2) - (2)])); ;} break; - case 999: /* b_expr: b_expr IS DISTINCT FROM b_expr */ + case 1002: #line 2641 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_DISTINCT, "=", (yyvsp[-4].node), (yyvsp[0].node), (yylsp[-3])); - } -#line 27193 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_DISTINCT, "=", (yyvsp[(1) - (5)].node), (yyvsp[(5) - (5)].node), (yylsp[(2) - (5)])); + ;} break; - case 1000: /* b_expr: b_expr IS NOT DISTINCT FROM b_expr */ + case 1003: #line 2645 "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 27201 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_NOT_DISTINCT, "=", (yyvsp[(1) - (6)].node), (yyvsp[(6) - (6)].node), (yylsp[(2) - (6)])); + ;} break; - case 1001: /* b_expr: b_expr IS OF '(' type_list ')' */ + case 1004: #line 2649 "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 27209 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OF, "=", (yyvsp[(1) - (6)].node), (PGNode *) (yyvsp[(5) - (6)].list), (yylsp[(2) - (6)])); + ;} break; - case 1002: /* b_expr: b_expr IS NOT OF '(' type_list ')' */ + case 1005: #line 2653 "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 27217 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OF, "<>", (yyvsp[(1) - (7)].node), (PGNode *) (yyvsp[(6) - (7)].list), (yylsp[(2) - (7)])); + ;} break; - case 1004: /* c_expr: indirection_expr_or_a_expr opt_extended_indirection */ + case 1007: #line 2668 "third_party/libpg_query/grammar/statements/select.y" - { - if ((yyvsp[0].list)) + { + 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 27233 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = (PGNode *) (yyvsp[(1) - (2)].node); + ;} break; - case 1005: /* d_expr: columnref */ + case 1008: #line 2681 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 27239 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 1006: /* d_expr: AexprConst */ + case 1009: #line 2682 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 27245 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 1007: /* d_expr: select_with_parens */ + case 1010: #line 2684 "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 27260 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1008: /* d_expr: select_with_parens indirection */ + case 1011: #line 2695 "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 @@ -27278,280 +27416,254 @@ 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 27288 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1009: /* d_expr: EXISTS select_with_parens */ + case 1012: #line 2719 "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 27303 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1010: /* d_expr: grouping_or_grouping_id '(' expr_list_opt_comma ')' */ + case 1013: #line 2730 "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 27314 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1011: /* indirection_expr_or_a_expr: '(' a_expr ')' */ + case 1014: #line 2740 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (yyvsp[-1].node); - } -#line 27322 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (yyvsp[(2) - (3)].node); + ;} break; - case 1012: /* indirection_expr_or_a_expr: indirection_expr */ + case 1015: #line 2744 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (yyvsp[0].node); - } -#line 27330 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (yyvsp[(1) - (1)].node); + ;} break; - case 1013: /* indirection_expr_or_a_expr: row */ + case 1016: #line 2747 "third_party/libpg_query/grammar/statements/select.y" - { - PGFuncCall *n = makeFuncCall(SystemFuncName("row"), (yyvsp[0].list), (yylsp[0])); + { + PGFuncCall *n = makeFuncCall(SystemFuncName("row"), (yyvsp[(1) - (1)].list), (yylsp[(1) - (1)])); (yyval.node) = (PGNode *) n; - } -#line 27339 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1014: /* indirection_expr: '?' */ + case 1017: #line 2755 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeParamRef(0, (yylsp[0])); - } -#line 27347 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeParamRef(0, (yylsp[(1) - (1)])); + ;} break; - case 1015: /* indirection_expr: PARAM */ + case 1018: #line 2759 "third_party/libpg_query/grammar/statements/select.y" - { + { PGParamRef *p = makeNode(PGParamRef); - p->number = (yyvsp[0].ival); - p->location = (yylsp[0]); + p->number = (yyvsp[(1) - (1)].ival); + p->location = (yylsp[(1) - (1)]); (yyval.node) = (PGNode *) p; - } -#line 27358 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1016: /* indirection_expr: struct_expr */ + case 1019: #line 2766 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (yyvsp[0].node); - } -#line 27366 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (yyvsp[(1) - (1)].node); + ;} break; - case 1017: /* indirection_expr: MAP '{' opt_map_arguments_opt_comma '}' */ + case 1020: #line 2770 "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 27387 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1018: /* indirection_expr: func_expr */ + case 1021: #line 2787 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (yyvsp[0].node); - } -#line 27395 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (yyvsp[(1) - (1)].node); + ;} break; - case 1019: /* indirection_expr: case_expr */ + case 1022: #line 2791 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 27401 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 1020: /* indirection_expr: list_expr */ + case 1023: #line 2792 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (yyvsp[0].node); - } -#line 27409 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (yyvsp[(1) - (1)].node); + ;} break; - case 1021: /* indirection_expr: list_comprehension */ + case 1024: #line 2795 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (yyvsp[0].node); - } -#line 27417 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (yyvsp[(1) - (1)].node); + ;} break; - case 1022: /* indirection_expr: ARRAY select_with_parens */ + case 1025: #line 2799 "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]); + n->subselect = (yyvsp[(2) - (2)].node); + n->location = (yylsp[(2) - (2)]); (yyval.node) = (PGNode *)n; - } -#line 27432 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1023: /* indirection_expr: ARRAY '[' opt_expr_list_opt_comma ']' */ + case 1026: #line 2809 "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])); + PGFuncCall *n = makeFuncCall(func_name, (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)])); (yyval.node) = (PGNode *) n; - } -#line 27442 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1024: /* indirection_expr: '#' ICONST */ + case 1027: #line 2815 "third_party/libpg_query/grammar/statements/select.y" - { + { PGPositionalReference *n = makeNode(PGPositionalReference); - n->position = (yyvsp[0].ival); - n->location = (yylsp[-1]); + n->position = (yyvsp[(2) - (2)].ival); + n->location = (yylsp[(1) - (2)]); (yyval.node) = (PGNode *) n; - } -#line 27453 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1025: /* indirection_expr: '$' ColLabel */ + case 1028: #line 2822 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeNamedParamRef((yyvsp[0].str), (yylsp[-1])); - } -#line 27461 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeNamedParamRef((yyvsp[(2) - (2)].str), (yylsp[(1) - (2)])); + ;} break; - case 1026: /* list_expr: '[' opt_expr_list_opt_comma ']' */ + case 1029: #line 2827 "third_party/libpg_query/grammar/statements/select.y" - { - PGFuncCall *n = makeFuncCall(SystemFuncName("list_value"), (yyvsp[-1].list), (yylsp[-1])); + { + PGFuncCall *n = makeFuncCall(SystemFuncName("list_value"), (yyvsp[(2) - (3)].list), (yylsp[(2) - (3)])); (yyval.node) = (PGNode *) n; - } -#line 27470 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1027: /* struct_expr: '{' dict_arguments_opt_comma '}' */ + case 1030: #line 2834 "third_party/libpg_query/grammar/statements/select.y" - { - PGFuncCall *f = makeFuncCall(SystemFuncName("struct_pack"), (yyvsp[-1].list), (yylsp[-1])); + { + PGFuncCall *f = makeFuncCall(SystemFuncName("struct_pack"), (yyvsp[(2) - (3)].list), (yylsp[(2) - (3)])); (yyval.node) = (PGNode *) f; - } -#line 27479 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1028: /* func_application: func_name '(' ')' */ + case 1031: #line 2843 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeFuncCall((yyvsp[-2].list), NIL, (yylsp[-2])); - } -#line 27487 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (PGNode *) makeFuncCall((yyvsp[(1) - (3)].list), NIL, (yylsp[(1) - (3)])); + ;} break; - case 1029: /* func_application: func_name '(' func_arg_list opt_sort_clause opt_ignore_nulls ')' */ + case 1032: #line 2847 "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].ignorenulls); + { + 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)].ignorenulls); (yyval.node) = (PGNode *)n; - } -#line 27498 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1030: /* func_application: func_name '(' VARIADIC func_arg_expr opt_sort_clause opt_ignore_nulls ')' */ + case 1033: #line 2854 "third_party/libpg_query/grammar/statements/select.y" - { - PGFuncCall *n = makeFuncCall((yyvsp[-6].list), list_make1((yyvsp[-3].node)), (yylsp[-6])); + { + 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].ignorenulls); + n->agg_order = (yyvsp[(5) - (7)].list); + n->agg_ignore_nulls = (yyvsp[(6) - (7)].ignorenulls); (yyval.node) = (PGNode *)n; - } -#line 27510 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1031: /* func_application: func_name '(' func_arg_list ',' VARIADIC func_arg_expr opt_sort_clause opt_ignore_nulls ')' */ + case 1034: #line 2862 "third_party/libpg_query/grammar/statements/select.y" - { - PGFuncCall *n = makeFuncCall((yyvsp[-8].list), lappend((yyvsp[-6].list), (yyvsp[-3].node)), (yylsp[-8])); + { + 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].ignorenulls); + n->agg_order = (yyvsp[(7) - (9)].list); + n->agg_ignore_nulls = (yyvsp[(8) - (9)].ignorenulls); (yyval.node) = (PGNode *)n; - } -#line 27522 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1032: /* func_application: func_name '(' ALL func_arg_list opt_sort_clause opt_ignore_nulls ')' */ + case 1035: #line 2870 "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].ignorenulls); + { + 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)].ignorenulls); /* 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 27537 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1033: /* func_application: func_name '(' DISTINCT func_arg_list opt_sort_clause opt_ignore_nulls ')' */ + case 1036: #line 2881 "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].ignorenulls); + { + 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)].ignorenulls); n->agg_distinct = true; (yyval.node) = (PGNode *)n; - } -#line 27549 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1034: /* func_expr: func_application within_group_clause filter_clause export_clause over_clause */ + case 1037: #line 2901 "third_party/libpg_query/grammar/statements/select.y" - { - PGFuncCall *n = (PGFuncCall *) (yyvsp[-4].node); + { + 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 @@ -27560,118 +27672,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 27589 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1035: /* func_expr: func_expr_common_subexpr */ + case 1038: #line 2937 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 27595 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 1036: /* func_expr_windowless: func_application */ + case 1039: #line 2947 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 27601 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 1037: /* func_expr_windowless: func_expr_common_subexpr */ + case 1040: #line 2948 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 27607 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 1038: /* func_expr_common_subexpr: COLLATION FOR '(' a_expr ')' */ + case 1041: #line 2956 "third_party/libpg_query/grammar/statements/select.y" - { + { (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("pg_collation_for"), - list_make1((yyvsp[-1].node)), - (yylsp[-4])); - } -#line 27617 "third_party/libpg_query/grammar/grammar_out.cpp" + list_make1((yyvsp[(4) - (5)].node)), + (yylsp[(1) - (5)])); + ;} break; - case 1039: /* func_expr_common_subexpr: CAST '(' a_expr AS Typename ')' */ + case 1042: #line 2962 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = makeTypeCast((yyvsp[-3].node), (yyvsp[-1].typnam), 0, (yylsp[-5])); } -#line 27623 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = makeTypeCast((yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].typnam), 0, (yylsp[(1) - (6)])); ;} break; - case 1040: /* func_expr_common_subexpr: TRY_CAST '(' a_expr AS Typename ')' */ + case 1043: #line 2964 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = makeTypeCast((yyvsp[-3].node), (yyvsp[-1].typnam), 1, (yylsp[-5])); } -#line 27629 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = makeTypeCast((yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].typnam), 1, (yylsp[(1) - (6)])); ;} break; - case 1041: /* func_expr_common_subexpr: EXTRACT '(' extract_list ')' */ + case 1044: #line 2966 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("date_part"), (yyvsp[-1].list), (yylsp[-3])); - } -#line 27637 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("date_part"), (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)])); + ;} break; - case 1042: /* func_expr_common_subexpr: OVERLAY '(' overlay_list ')' */ + case 1045: #line 2970 "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 27650 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("overlay"), (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)])); + ;} break; - case 1043: /* func_expr_common_subexpr: POSITION '(' position_list ')' */ + case 1046: #line 2979 "third_party/libpg_query/grammar/statements/select.y" - { + { /* position(A in B) is converted to position_inverse(A, B) */ - (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("__internal_position_operator"), (yyvsp[-1].list), (yylsp[-3])); - } -#line 27659 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("__internal_position_operator"), (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)])); + ;} break; - case 1044: /* func_expr_common_subexpr: SUBSTRING '(' substr_list ')' */ + case 1047: #line 2984 "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 27670 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("substring"), (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)])); + ;} break; - case 1045: /* func_expr_common_subexpr: TREAT '(' a_expr AS Typename ')' */ + case 1048: #line 2991 "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, @@ -27681,322 +27782,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 27689 "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 1046: /* func_expr_common_subexpr: TRIM '(' BOTH trim_list ')' */ + case 1049: #line 3006 "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 27700 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("trim"), (yyvsp[(4) - (5)].list), (yylsp[(1) - (5)])); + ;} break; - case 1047: /* func_expr_common_subexpr: TRIM '(' LEADING trim_list ')' */ + case 1050: #line 3013 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("ltrim"), (yyvsp[-1].list), (yylsp[-4])); - } -#line 27708 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("ltrim"), (yyvsp[(4) - (5)].list), (yylsp[(1) - (5)])); + ;} break; - case 1048: /* func_expr_common_subexpr: TRIM '(' TRAILING trim_list ')' */ + case 1051: #line 3017 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("rtrim"), (yyvsp[-1].list), (yylsp[-4])); - } -#line 27716 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("rtrim"), (yyvsp[(4) - (5)].list), (yylsp[(1) - (5)])); + ;} break; - case 1049: /* func_expr_common_subexpr: TRIM '(' trim_list ')' */ + case 1052: #line 3021 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("trim"), (yyvsp[-1].list), (yylsp[-3])); - } -#line 27724 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("trim"), (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)])); + ;} break; - case 1050: /* func_expr_common_subexpr: NULLIF '(' a_expr ',' a_expr ')' */ + case 1053: #line 3025 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_NULLIF, "=", (yyvsp[-3].node), (yyvsp[-1].node), (yylsp[-5])); - } -#line 27732 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_NULLIF, "=", (yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].node), (yylsp[(1) - (6)])); + ;} break; - case 1051: /* func_expr_common_subexpr: COALESCE '(' expr_list_opt_comma ')' */ + case 1054: #line 3029 "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 27743 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1052: /* list_comprehension: '[' a_expr FOR ColId IN_P a_expr ']' */ + case 1055: #line 3039 "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 27756 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1053: /* list_comprehension: '[' a_expr FOR ColId IN_P c_expr IF_P a_expr ']' */ + case 1056: #line 3048 "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 27775 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1054: /* within_group_clause: WITHIN GROUP_P '(' sort_clause ')' */ + case 1057: #line 3069 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 27781 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(4) - (5)].list); ;} break; - case 1055: /* within_group_clause: %empty */ + case 1058: #line 3070 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 27787 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 1056: /* filter_clause: FILTER '(' WHERE a_expr ')' */ + case 1059: #line 3074 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[-1].node); } -#line 27793 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(4) - (5)].node); ;} break; - case 1057: /* filter_clause: FILTER '(' a_expr ')' */ + case 1060: #line 3075 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[-1].node); } -#line 27799 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(3) - (4)].node); ;} break; - case 1058: /* filter_clause: %empty */ + case 1061: #line 3076 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = NULL; } -#line 27805 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = NULL; ;} break; - case 1059: /* export_clause: EXPORT_STATE */ + case 1062: #line 3080 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = true; } -#line 27811 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = true; ;} break; - case 1060: /* export_clause: %empty */ + case 1063: #line 3081 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.boolean) = false; } -#line 27817 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = false; ;} break; - case 1061: /* window_clause: WINDOW window_definition_list */ + case 1064: #line 3088 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 27823 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (2)].list); ;} break; - case 1062: /* window_clause: %empty */ + case 1065: #line 3089 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 27829 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 1063: /* window_definition_list: window_definition */ + case 1066: #line 3093 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].windef)); } -#line 27835 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].windef)); ;} break; - case 1064: /* window_definition_list: window_definition_list ',' window_definition */ + case 1067: #line 3095 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].windef)); } -#line 27841 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].windef)); ;} break; - case 1065: /* window_definition: ColId AS window_specification */ + case 1068: #line 3100 "third_party/libpg_query/grammar/statements/select.y" - { - PGWindowDef *n = (yyvsp[0].windef); - n->name = (yyvsp[-2].str); + { + PGWindowDef *n = (yyvsp[(3) - (3)].windef); + n->name = (yyvsp[(1) - (3)].str); (yyval.windef) = n; - } -#line 27851 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1066: /* over_clause: OVER window_specification */ + case 1069: #line 3108 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.windef) = (yyvsp[0].windef); } -#line 27857 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.windef) = (yyvsp[(2) - (2)].windef); ;} break; - case 1067: /* over_clause: OVER ColId */ + case 1070: #line 3110 "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 27874 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1068: /* over_clause: %empty */ + case 1071: #line 3123 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.windef) = NULL; } -#line 27880 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.windef) = NULL; ;} break; - case 1069: /* window_specification: '(' opt_existing_window_name opt_partition_clause opt_sort_clause opt_frame_clause ')' */ + case 1072: #line 3128 "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 27898 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1070: /* opt_existing_window_name: ColId */ + case 1073: #line 3153 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (yyvsp[0].str); } -#line 27904 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1071: /* opt_existing_window_name: %empty */ + case 1074: #line 3154 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = NULL; } -#line 27910 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = NULL; ;} break; - case 1072: /* opt_partition_clause: PARTITION BY expr_list */ + case 1075: #line 3157 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 27916 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(3) - (3)].list); ;} break; - case 1073: /* opt_partition_clause: %empty */ + case 1076: #line 3158 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 27922 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 1074: /* opt_frame_clause: RANGE frame_extent opt_window_exclusion_clause */ + case 1077: #line 3167 "third_party/libpg_query/grammar/statements/select.y" - { - PGWindowDef *n = (yyvsp[-1].windef); + { + 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 27934 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1075: /* opt_frame_clause: ROWS frame_extent opt_window_exclusion_clause */ + case 1078: #line 3175 "third_party/libpg_query/grammar/statements/select.y" - { - PGWindowDef *n = (yyvsp[-1].windef); + { + 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 27946 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1076: /* opt_frame_clause: GROUPS frame_extent opt_window_exclusion_clause */ + case 1079: #line 3183 "third_party/libpg_query/grammar/statements/select.y" - { - PGWindowDef *n = (yyvsp[-1].windef); + { + 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 27958 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1077: /* opt_frame_clause: %empty */ + case 1080: #line 3191 "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 27971 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1078: /* frame_extent: frame_bound */ + case 1081: #line 3202 "third_party/libpg_query/grammar/statements/select.y" - { - PGWindowDef *n = (yyvsp[0].windef); + { + 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 27993 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1079: /* frame_extent: BETWEEN frame_bound AND frame_bound */ + case 1082: #line 3220 "third_party/libpg_query/grammar/statements/select.y" - { - PGWindowDef *n1 = (yyvsp[-2].windef); - PGWindowDef *n2 = (yyvsp[0].windef); + { + PGWindowDef *n1 = (yyvsp[(2) - (4)].windef); + PGWindowDef *n2 = (yyvsp[(4) - (4)].windef); /* form merged options */ int frameOptions = n1->frameOptions; @@ -28008,738 +28075,636 @@ 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 28035 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1080: /* frame_bound: UNBOUNDED PRECEDING */ + case 1083: #line 3266 "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 28048 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1081: /* frame_bound: UNBOUNDED FOLLOWING */ + case 1084: #line 3275 "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 28061 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1082: /* frame_bound: CURRENT_P ROW */ + case 1085: #line 3284 "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 28074 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1083: /* frame_bound: a_expr PRECEDING */ + case 1086: #line 3293 "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 28087 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1084: /* frame_bound: a_expr FOLLOWING */ + case 1087: #line 3302 "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 28100 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1085: /* opt_window_exclusion_clause: EXCLUDE CURRENT_P ROW */ + case 1088: #line 3313 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ival) = FRAMEOPTION_EXCLUDE_CURRENT_ROW; } -#line 28106 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = FRAMEOPTION_EXCLUDE_CURRENT_ROW; ;} break; - case 1086: /* opt_window_exclusion_clause: EXCLUDE GROUP_P */ + case 1089: #line 3314 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ival) = FRAMEOPTION_EXCLUDE_GROUP; } -#line 28112 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = FRAMEOPTION_EXCLUDE_GROUP; ;} break; - case 1087: /* opt_window_exclusion_clause: EXCLUDE TIES */ + case 1090: #line 3315 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ival) = FRAMEOPTION_EXCLUDE_TIES; } -#line 28118 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = FRAMEOPTION_EXCLUDE_TIES; ;} break; - case 1088: /* opt_window_exclusion_clause: EXCLUDE NO OTHERS */ + case 1091: #line 3316 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ival) = 0; } -#line 28124 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = 0; ;} break; - case 1089: /* opt_window_exclusion_clause: %empty */ + case 1092: #line 3317 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ival) = 0; } -#line 28130 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = 0; ;} break; - case 1090: /* qualified_row: ROW '(' expr_list_opt_comma ')' */ + case 1093: #line 3331 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 28136 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; - case 1091: /* qualified_row: ROW '(' ')' */ + case 1094: #line 3332 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 28142 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 1092: /* row: qualified_row */ + case 1095: #line 3335 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list);} -#line 28148 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list);;} break; - case 1093: /* row: '(' expr_list ',' a_expr ')' */ + case 1096: #line 3336 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-3].list), (yyvsp[-1].node)); } -#line 28154 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(2) - (5)].list), (yyvsp[(4) - (5)].node)); ;} break; - case 1094: /* dict_arg: ColIdOrString ':' a_expr */ + case 1097: #line 3340 "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 28167 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1095: /* dict_arguments: dict_arg */ + case 1098: #line 3350 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].node)); } -#line 28173 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 1096: /* dict_arguments: dict_arguments ',' dict_arg */ + case 1099: #line 3351 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].node)); } -#line 28179 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; - case 1097: /* dict_arguments_opt_comma: dict_arguments */ + case 1100: #line 3355 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 28185 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1098: /* dict_arguments_opt_comma: dict_arguments ',' */ + case 1101: #line 3356 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 28191 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 1099: /* map_arg: a_expr ':' a_expr */ + case 1102: #line 3361 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = list_make2((yyvsp[-2].node), (yyvsp[0].node)); - } -#line 28199 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = list_make2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + ;} break; - case 1100: /* map_arguments: map_arg */ + case 1103: #line 3367 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].list)); } -#line 28205 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].list)); ;} break; - case 1101: /* map_arguments: map_arguments ',' map_arg */ + case 1104: #line 3368 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].list)); } -#line 28211 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); ;} break; - case 1102: /* map_arguments_opt_comma: map_arguments */ + case 1105: #line 3373 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 28217 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1103: /* map_arguments_opt_comma: map_arguments ',' */ + case 1106: #line 3374 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 28223 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 1104: /* opt_map_arguments_opt_comma: map_arguments_opt_comma */ + case 1107: #line 3379 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 28229 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1105: /* opt_map_arguments_opt_comma: %empty */ + case 1108: #line 3380 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NULL; } -#line 28235 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NULL; ;} break; - case 1106: /* sub_type: ANY */ + case 1109: #line 3383 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.subquerytype) = PG_ANY_SUBLINK; } -#line 28241 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.subquerytype) = PG_ANY_SUBLINK; ;} break; - case 1107: /* sub_type: SOME */ + case 1110: #line 3384 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.subquerytype) = PG_ANY_SUBLINK; } -#line 28247 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.subquerytype) = PG_ANY_SUBLINK; ;} break; - case 1108: /* sub_type: ALL */ + case 1111: #line 3385 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.subquerytype) = PG_ALL_SUBLINK; } -#line 28253 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.subquerytype) = PG_ALL_SUBLINK; ;} break; - case 1109: /* all_Op: Op */ + case 1112: #line 3388 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (yyvsp[0].str); } -#line 28259 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1110: /* all_Op: MathOp */ + case 1113: #line 3389 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (char*) (yyvsp[0].conststr); } -#line 28265 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (char*) (yyvsp[(1) - (1)].conststr); ;} break; - case 1111: /* MathOp: '+' */ + case 1114: #line 3392 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = "+"; } -#line 28271 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.conststr) = "+"; ;} break; - case 1112: /* MathOp: '-' */ + case 1115: #line 3393 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = "-"; } -#line 28277 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.conststr) = "-"; ;} break; - case 1113: /* MathOp: '*' */ + case 1116: #line 3394 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = "*"; } -#line 28283 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.conststr) = "*"; ;} break; - case 1114: /* MathOp: '/' */ + case 1117: #line 3395 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = "/"; } -#line 28289 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.conststr) = "/"; ;} break; - case 1115: /* MathOp: INTEGER_DIVISION */ + case 1118: #line 3396 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = "//"; } -#line 28295 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.conststr) = "//"; ;} break; - case 1116: /* MathOp: '%' */ + case 1119: #line 3397 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = "%"; } -#line 28301 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.conststr) = "%"; ;} break; - case 1117: /* MathOp: '^' */ + case 1120: #line 3398 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = "^"; } -#line 28307 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.conststr) = "^"; ;} break; - case 1118: /* MathOp: POWER_OF */ + case 1121: #line 3399 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = "**"; } -#line 28313 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.conststr) = "**"; ;} break; - case 1119: /* MathOp: '<' */ + case 1122: #line 3400 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = "<"; } -#line 28319 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.conststr) = "<"; ;} break; - case 1120: /* MathOp: '>' */ + case 1123: #line 3401 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = ">"; } -#line 28325 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.conststr) = ">"; ;} break; - case 1121: /* MathOp: '=' */ + case 1124: #line 3402 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = "="; } -#line 28331 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.conststr) = "="; ;} break; - case 1122: /* MathOp: LESS_EQUALS */ + case 1125: #line 3403 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = "<="; } -#line 28337 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.conststr) = "<="; ;} break; - case 1123: /* MathOp: GREATER_EQUALS */ + case 1126: #line 3404 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = ">="; } -#line 28343 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.conststr) = ">="; ;} break; - case 1124: /* MathOp: NOT_EQUALS */ + case 1127: #line 3405 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.conststr) = "<>"; } -#line 28349 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.conststr) = "<>"; ;} break; - case 1125: /* qual_Op: Op */ + case 1128: #line 3409 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString((yyvsp[0].str))); } -#line 28355 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; - case 1126: /* qual_Op: OPERATOR '(' any_operator ')' */ + case 1129: #line 3411 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 28361 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; - case 1127: /* qual_all_Op: all_Op */ + case 1130: #line 3416 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString((yyvsp[0].str))); } -#line 28367 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; - case 1128: /* qual_all_Op: OPERATOR '(' any_operator ')' */ + case 1131: #line 3418 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 28373 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; - case 1129: /* subquery_Op: all_Op */ + case 1132: #line 3423 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString((yyvsp[0].str))); } -#line 28379 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; - case 1130: /* subquery_Op: OPERATOR '(' any_operator ')' */ + case 1133: #line 3425 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 28385 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; - case 1131: /* subquery_Op: LIKE */ + case 1134: #line 3427 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString("~~")); } -#line 28391 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeString("~~")); ;} break; - case 1132: /* subquery_Op: NOT_LA LIKE */ + case 1135: #line 3429 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString("!~~")); } -#line 28397 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeString("!~~")); ;} break; - case 1133: /* subquery_Op: GLOB */ + case 1136: #line 3431 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString("~~~")); } -#line 28403 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeString("~~~")); ;} break; - case 1134: /* subquery_Op: NOT_LA GLOB */ + case 1137: #line 3433 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString("!~~~")); } -#line 28409 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeString("!~~~")); ;} break; - case 1135: /* subquery_Op: ILIKE */ + case 1138: #line 3435 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString("~~*")); } -#line 28415 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeString("~~*")); ;} break; - case 1136: /* subquery_Op: NOT_LA ILIKE */ + case 1139: #line 3437 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString("!~~*")); } -#line 28421 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeString("!~~*")); ;} break; - case 1137: /* any_operator: all_Op */ + case 1140: #line 3451 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString((yyvsp[0].str))); } -#line 28427 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; - case 1138: /* any_operator: ColId '.' any_operator */ + case 1141: #line 3453 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lcons(makeString((yyvsp[-2].str)), (yyvsp[0].list)); } -#line 28433 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lcons(makeString((yyvsp[(1) - (3)].str)), (yyvsp[(3) - (3)].list)); ;} break; - case 1139: /* c_expr_list: c_expr */ + case 1142: #line 3458 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = list_make1((yyvsp[0].node)); - } -#line 28441 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); + ;} break; - case 1140: /* c_expr_list: c_expr_list ',' c_expr */ + case 1143: #line 3462 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].node)); - } -#line 28449 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); + ;} break; - case 1141: /* c_expr_list_opt_comma: c_expr_list */ + case 1144: #line 3469 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = (yyvsp[0].list); - } -#line 28457 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = (yyvsp[(1) - (1)].list); + ;} break; - case 1142: /* c_expr_list_opt_comma: c_expr_list ',' */ + case 1145: #line 3474 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = (yyvsp[-1].list); - } -#line 28465 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = (yyvsp[(1) - (2)].list); + ;} break; - case 1143: /* expr_list: a_expr */ + case 1146: #line 3480 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = list_make1((yyvsp[0].node)); - } -#line 28473 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); + ;} break; - case 1144: /* expr_list: expr_list ',' a_expr */ + case 1147: #line 3484 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].node)); - } -#line 28481 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); + ;} break; - case 1145: /* expr_list_opt_comma: expr_list */ + case 1148: #line 3491 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = (yyvsp[0].list); - } -#line 28489 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = (yyvsp[(1) - (1)].list); + ;} break; - case 1146: /* expr_list_opt_comma: expr_list ',' */ + case 1149: #line 3496 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = (yyvsp[-1].list); - } -#line 28497 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = (yyvsp[(1) - (2)].list); + ;} break; - case 1147: /* opt_expr_list_opt_comma: expr_list_opt_comma */ + case 1150: #line 3503 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = (yyvsp[0].list); - } -#line 28505 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = (yyvsp[(1) - (1)].list); + ;} break; - case 1148: /* opt_expr_list_opt_comma: %empty */ + case 1151: #line 3507 "third_party/libpg_query/grammar/statements/select.y" - { + { (yyval.list) = NULL; - } -#line 28513 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1149: /* func_arg_list: func_arg_expr */ + case 1152: #line 3516 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = list_make1((yyvsp[0].node)); - } -#line 28521 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); + ;} break; - case 1150: /* func_arg_list: func_arg_list ',' func_arg_expr */ + case 1153: #line 3520 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].node)); - } -#line 28529 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); + ;} break; - case 1151: /* func_arg_expr: a_expr */ + case 1154: #line 3526 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = (yyvsp[0].node); - } -#line 28537 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = (yyvsp[(1) - (1)].node); + ;} break; - case 1152: /* func_arg_expr: param_name COLON_EQUALS a_expr */ + case 1155: #line 3530 "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 28550 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1153: /* func_arg_expr: param_name EQUALS_GREATER a_expr */ + case 1156: #line 3539 "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 28563 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1154: /* type_list: Typename */ + case 1157: #line 3549 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].typnam)); } -#line 28569 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].typnam)); ;} break; - case 1155: /* type_list: type_list ',' Typename */ + case 1158: #line 3550 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].typnam)); } -#line 28575 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].typnam)); ;} break; - case 1156: /* extract_list: extract_arg FROM a_expr */ + case 1159: #line 3555 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = list_make2(makeStringConst((yyvsp[-2].str), (yylsp[-2])), (yyvsp[0].node)); - } -#line 28583 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = list_make2(makeStringConst((yyvsp[(1) - (3)].str), (yylsp[(1) - (3)])), (yyvsp[(3) - (3)].node)); + ;} break; - case 1157: /* extract_list: %empty */ + case 1160: #line 3558 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 28589 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 1158: /* extract_arg: IDENT */ + case 1161: #line 3565 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (yyvsp[0].str); } -#line 28595 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1159: /* extract_arg: year_keyword */ + case 1162: #line 3566 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (char*) "year"; } -#line 28601 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (char*) "year"; ;} break; - case 1160: /* extract_arg: month_keyword */ + case 1163: #line 3567 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (char*) "month"; } -#line 28607 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (char*) "month"; ;} break; - case 1161: /* extract_arg: day_keyword */ + case 1164: #line 3568 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (char*) "day"; } -#line 28613 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (char*) "day"; ;} break; - case 1162: /* extract_arg: hour_keyword */ + case 1165: #line 3569 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (char*) "hour"; } -#line 28619 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (char*) "hour"; ;} break; - case 1163: /* extract_arg: minute_keyword */ + case 1166: #line 3570 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (char*) "minute"; } -#line 28625 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (char*) "minute"; ;} break; - case 1164: /* extract_arg: second_keyword */ + case 1167: #line 3571 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (char*) "second"; } -#line 28631 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (char*) "second"; ;} break; - case 1165: /* extract_arg: millisecond_keyword */ + case 1168: #line 3572 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (char*) "millisecond"; } -#line 28637 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (char*) "millisecond"; ;} break; - case 1166: /* extract_arg: microsecond_keyword */ + case 1169: #line 3573 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (char*) "microsecond"; } -#line 28643 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (char*) "microsecond"; ;} break; - case 1167: /* extract_arg: week_keyword */ + case 1170: #line 3574 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (char*) "week"; } -#line 28649 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (char*) "week"; ;} break; - case 1168: /* extract_arg: quarter_keyword */ + case 1171: #line 3575 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (char*) "quarter"; } -#line 28655 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (char*) "quarter"; ;} break; - case 1169: /* extract_arg: decade_keyword */ + case 1172: #line 3576 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (char*) "decade"; } -#line 28661 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (char*) "decade"; ;} break; - case 1170: /* extract_arg: century_keyword */ + case 1173: #line 3577 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (char*) "century"; } -#line 28667 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (char*) "century"; ;} break; - case 1171: /* extract_arg: millennium_keyword */ + case 1174: #line 3578 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (char*) "millennium"; } -#line 28673 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (char*) "millennium"; ;} break; - case 1172: /* extract_arg: Sconst */ + case 1175: #line 3579 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (yyvsp[0].str); } -#line 28679 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1173: /* overlay_list: a_expr overlay_placing substr_from substr_for */ + case 1176: #line 3590 "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 28687 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = list_make4((yyvsp[(1) - (4)].node), (yyvsp[(2) - (4)].node), (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].node)); + ;} break; - case 1174: /* overlay_list: a_expr overlay_placing substr_from */ + case 1177: #line 3594 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = list_make3((yyvsp[-2].node), (yyvsp[-1].node), (yyvsp[0].node)); - } -#line 28695 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = list_make3((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node), (yyvsp[(3) - (3)].node)); + ;} break; - case 1175: /* overlay_placing: PLACING a_expr */ + case 1178: #line 3601 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 28701 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 1176: /* position_list: b_expr IN_P b_expr */ + case 1179: #line 3607 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make2((yyvsp[-2].node), (yyvsp[0].node)); } -#line 28707 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); ;} break; - case 1177: /* position_list: %empty */ + case 1180: #line 3608 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 28713 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 1178: /* substr_list: a_expr substr_from substr_for */ + case 1181: #line 3625 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = list_make3((yyvsp[-2].node), (yyvsp[-1].node), (yyvsp[0].node)); - } -#line 28721 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = list_make3((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node), (yyvsp[(3) - (3)].node)); + ;} break; - case 1179: /* substr_list: a_expr substr_for substr_from */ + case 1182: #line 3629 "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 28730 "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 1180: /* substr_list: a_expr substr_from */ + case 1183: #line 3634 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = list_make2((yyvsp[-1].node), (yyvsp[0].node)); - } -#line 28738 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = list_make2((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node)); + ;} break; - case 1181: /* substr_list: a_expr substr_for */ + case 1184: #line 3638 "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 @@ -28749,599 +28714,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 28757 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1182: /* substr_list: expr_list */ + case 1185: #line 3653 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = (yyvsp[0].list); - } -#line 28765 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = (yyvsp[(1) - (1)].list); + ;} break; - case 1183: /* substr_list: %empty */ + case 1186: #line 3657 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 28771 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 1184: /* substr_from: FROM a_expr */ + case 1187: #line 3661 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 28777 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 1185: /* substr_for: FOR a_expr */ + case 1188: #line 3664 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 28783 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 1186: /* trim_list: a_expr FROM expr_list_opt_comma */ + case 1189: #line 3667 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[0].list), (yyvsp[-2].node)); } -#line 28789 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(3) - (3)].list), (yyvsp[(1) - (3)].node)); ;} break; - case 1187: /* trim_list: FROM expr_list_opt_comma */ + case 1190: #line 3668 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 28795 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (2)].list); ;} break; - case 1188: /* trim_list: expr_list_opt_comma */ + case 1191: #line 3669 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 28801 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1189: /* in_expr: select_with_parens */ + case 1192: #line 3673 "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 28812 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1190: /* in_expr: '(' expr_list_opt_comma ')' */ + case 1193: #line 3679 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (PGNode *)(yyvsp[-1].list); } -#line 28818 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *)(yyvsp[(2) - (3)].list); ;} break; - case 1191: /* case_expr: CASE case_arg when_clause_list case_default END_P */ + case 1194: #line 3690 "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 28832 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1192: /* when_clause_list: when_clause */ + case 1195: #line 3703 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].node)); } -#line 28838 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 1193: /* when_clause_list: when_clause_list when_clause */ + case 1196: #line 3704 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-1].list), (yyvsp[0].node)); } -#line 28844 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;} break; - case 1194: /* when_clause: WHEN a_expr THEN a_expr */ + case 1197: #line 3709 "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 28856 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1195: /* case_default: ELSE a_expr */ + case 1198: #line 3719 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 28862 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 1196: /* case_default: %empty */ + case 1199: #line 3720 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = NULL; } -#line 28868 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = NULL; ;} break; - case 1197: /* case_arg: a_expr */ + case 1200: #line 3723 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 28874 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 1198: /* case_arg: %empty */ + case 1201: #line 3724 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = NULL; } -#line 28880 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = NULL; ;} break; - case 1199: /* columnref: ColId */ + case 1202: #line 3728 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeColumnRef((yyvsp[0].str), NIL, (yylsp[0]), yyscanner); - } -#line 28888 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeColumnRef((yyvsp[(1) - (1)].str), NIL, (yylsp[(1) - (1)]), yyscanner); + ;} break; - case 1200: /* columnref: ColId indirection */ + case 1203: #line 3732 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeColumnRef((yyvsp[-1].str), (yyvsp[0].list), (yylsp[-1]), yyscanner); - } -#line 28896 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeColumnRef((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].list), (yylsp[(1) - (2)]), yyscanner); + ;} break; - case 1201: /* indirection_el: '[' a_expr ']' */ + case 1204: #line 3739 "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 28908 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1202: /* indirection_el: '[' opt_slice_bound ':' opt_slice_bound ']' */ + case 1205: #line 3747 "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 28920 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1203: /* indirection_el: '[' opt_slice_bound ':' opt_slice_bound ':' opt_slice_bound ']' */ + case 1206: #line 3754 "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 28933 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1204: /* indirection_el: '[' opt_slice_bound ':' '-' ':' opt_slice_bound ']' */ + case 1207: #line 3762 "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 28945 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1205: /* opt_slice_bound: a_expr */ + case 1208: #line 3772 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = (yyvsp[0].node); } -#line 28951 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 1206: /* opt_slice_bound: %empty */ + case 1209: #line 3773 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.node) = NULL; } -#line 28957 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = NULL; ;} break; - case 1207: /* opt_indirection: %empty */ + case 1210: #line 3778 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 28963 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 1208: /* opt_indirection: opt_indirection indirection_el */ + case 1211: #line 3779 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-1].list), (yyvsp[0].node)); } -#line 28969 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;} break; - case 1209: /* opt_func_arguments: %empty */ + case 1212: #line 3783 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NULL; } -#line 28975 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NULL; ;} break; - case 1210: /* opt_func_arguments: '(' ')' */ + case 1213: #line 3784 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(NULL); } -#line 28981 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(NULL); ;} break; - case 1211: /* opt_func_arguments: '(' func_arg_list ')' */ + case 1214: #line 3785 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 28987 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 1212: /* extended_indirection_el: '.' attr_name opt_func_arguments */ + case 1215: #line 3790 "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])); + { + 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 29000 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1213: /* extended_indirection_el: '[' a_expr ']' */ + case 1216: #line 3799 "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 29012 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1214: /* extended_indirection_el: '[' opt_slice_bound ':' opt_slice_bound ']' */ + case 1217: #line 3807 "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 29024 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1215: /* extended_indirection_el: '[' opt_slice_bound ':' opt_slice_bound ':' opt_slice_bound ']' */ + case 1218: #line 3814 "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 29037 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1216: /* extended_indirection_el: '[' opt_slice_bound ':' '-' ':' opt_slice_bound ']' */ + case 1219: #line 3823 "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 29049 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1217: /* opt_extended_indirection: %empty */ + case 1220: #line 3838 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 29055 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 1218: /* opt_extended_indirection: opt_extended_indirection extended_indirection_el */ + case 1221: #line 3839 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-1].list), (yyvsp[0].node)); } -#line 29061 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;} break; - case 1221: /* opt_target_list_opt_comma: target_list_opt_comma */ + case 1224: #line 3855 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 29067 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1222: /* opt_target_list_opt_comma: %empty */ + case 1225: #line 3856 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 29073 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 1223: /* target_list: target_el */ + case 1226: #line 3860 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].target)); } -#line 29079 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].target)); ;} break; - case 1224: /* target_list: target_list ',' target_el */ + case 1227: #line 3861 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].target)); } -#line 29085 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].target)); ;} break; - case 1225: /* target_list_opt_comma: target_list */ + case 1228: #line 3865 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 29091 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1226: /* target_list_opt_comma: target_list ',' */ + case 1229: #line 3866 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 29097 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 1227: /* target_el: a_expr AS ColLabelOrString */ + case 1230: #line 3870 "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 29109 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.target)->val = (PGNode *)(yyvsp[(1) - (3)].node); + (yyval.target)->location = (yylsp[(1) - (3)]); + ;} break; - case 1228: /* target_el: a_expr IDENT */ + case 1231: #line 3886 "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 29121 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.target)->val = (PGNode *)(yyvsp[(1) - (2)].node); + (yyval.target)->location = (yylsp[(1) - (2)]); + ;} break; - case 1229: /* target_el: a_expr */ + case 1232: #line 3894 "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 29133 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.target)->val = (PGNode *)(yyvsp[(1) - (1)].node); + (yyval.target)->location = (yylsp[(1) - (1)]); + ;} break; - case 1230: /* except_list: EXCLUDE '(' name_list_opt_comma ')' */ + case 1233: #line 3903 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 29139 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; - case 1231: /* except_list: EXCLUDE ColId */ + case 1234: #line 3904 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString((yyvsp[0].str))); } -#line 29145 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeString((yyvsp[(2) - (2)].str))); ;} break; - case 1232: /* opt_except_list: except_list */ + case 1235: #line 3907 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 29151 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1233: /* opt_except_list: %empty */ + case 1236: #line 3908 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NULL; } -#line 29157 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NULL; ;} break; - case 1234: /* replace_list_el: a_expr AS ColId */ + case 1237: #line 3911 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make2((yyvsp[-2].node), makeString((yyvsp[0].str))); } -#line 29163 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make2((yyvsp[(1) - (3)].node), makeString((yyvsp[(3) - (3)].str))); ;} break; - case 1235: /* replace_list: replace_list_el */ + case 1238: #line 3915 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].list)); } -#line 29169 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].list)); ;} break; - case 1236: /* replace_list: replace_list ',' replace_list_el */ + case 1239: #line 3916 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].list)); } -#line 29175 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); ;} break; - case 1237: /* replace_list_opt_comma: replace_list */ + case 1240: #line 3920 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 29181 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1238: /* replace_list_opt_comma: replace_list ',' */ + case 1241: #line 3921 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 29187 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 1239: /* opt_replace_list: REPLACE '(' replace_list_opt_comma ')' */ + case 1242: #line 3924 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 29193 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; - case 1240: /* opt_replace_list: REPLACE replace_list_el */ + case 1243: #line 3925 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].list)); } -#line 29199 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(2) - (2)].list)); ;} break; - case 1241: /* opt_replace_list: %empty */ + case 1244: #line 3926 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NULL; } -#line 29205 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NULL; ;} break; - case 1242: /* qualified_name_list: qualified_name */ + case 1245: #line 3936 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1((yyvsp[0].range)); } -#line 29211 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].range)); ;} break; - case 1243: /* qualified_name_list: qualified_name_list ',' qualified_name */ + case 1246: #line 3937 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].range)); } -#line 29217 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].range)); ;} break; - case 1244: /* name_list: name */ + case 1247: #line 3942 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString((yyvsp[0].str))); } -#line 29223 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; - case 1245: /* name_list: name_list ',' name */ + case 1248: #line 3944 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), makeString((yyvsp[0].str))); } -#line 29229 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), makeString((yyvsp[(3) - (3)].str))); ;} break; - case 1246: /* name_list_opt_comma: name_list */ + case 1249: #line 3949 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 29235 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1247: /* name_list_opt_comma: name_list ',' */ + case 1250: #line 3950 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 29241 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 1248: /* name_list_opt_comma_opt_bracket: name_list_opt_comma */ + case 1251: #line 3954 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[0].list); } -#line 29247 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1249: /* name_list_opt_comma_opt_bracket: '(' name_list_opt_comma ')' */ + case 1252: #line 3955 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 29253 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 1250: /* name: ColIdOrString */ + case 1253: #line 3958 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (yyvsp[0].str); } -#line 29259 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1251: /* func_name: function_name_token */ + case 1254: #line 3970 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString((yyvsp[0].str))); } -#line 29265 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; - case 1252: /* func_name: ColId indirection */ + case 1255: #line 3973 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.list) = check_func_name(lcons(makeString((yyvsp[-1].str)), (yyvsp[0].list)), + { + (yyval.list) = check_func_name(lcons(makeString((yyvsp[(1) - (2)].str)), (yyvsp[(2) - (2)].list)), yyscanner); - } -#line 29274 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1253: /* AexprConst: Iconst */ + case 1256: #line 3984 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeIntConst((yyvsp[0].ival), (yylsp[0])); - } -#line 29282 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeIntConst((yyvsp[(1) - (1)].ival), (yylsp[(1) - (1)])); + ;} break; - case 1254: /* AexprConst: FCONST */ + case 1257: #line 3988 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeFloatConst((yyvsp[0].str), (yylsp[0])); - } -#line 29290 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeFloatConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); + ;} break; - case 1255: /* AexprConst: Sconst opt_indirection */ + case 1258: #line 3992 "third_party/libpg_query/grammar/statements/select.y" - { - if ((yyvsp[0].list)) + { + 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 29306 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = makeStringConst((yyvsp[(1) - (2)].str), (yylsp[(1) - (2)])); + ;} break; - case 1256: /* AexprConst: BCONST */ + case 1259: #line 4004 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeBitStringConst((yyvsp[0].str), (yylsp[0])); - } -#line 29314 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeBitStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); + ;} break; - case 1257: /* AexprConst: XCONST */ + case 1260: #line 4008 "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 29327 "third_party/libpg_query/grammar/grammar_out.cpp" + (yyval.node) = makeBitStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); + ;} break; - case 1258: /* AexprConst: func_name Sconst */ + case 1261: #line 4017 "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 29338 "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 1259: /* AexprConst: func_name '(' func_arg_list opt_sort_clause opt_ignore_nulls ')' Sconst */ + case 1262: #line 4024 "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; /* @@ -29350,7 +29239,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); @@ -29360,315 +29249,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].ignorenulls) != false) + parser_errposition((yylsp[(4) - (7)])))); + if ((yyvsp[(5) - (7)].ignorenulls) != 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 29380 "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 1260: /* AexprConst: ConstTypename Sconst */ + case 1263: #line 4062 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeStringConstCast((yyvsp[0].str), (yylsp[0]), (yyvsp[-1].typnam)); - } -#line 29388 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeStringConstCast((yyvsp[(2) - (2)].str), (yylsp[(2) - (2)]), (yyvsp[(1) - (2)].typnam)); + ;} break; - case 1261: /* AexprConst: ConstInterval '(' a_expr ')' opt_interval */ + case 1264: #line 4066 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeIntervalNode((yyvsp[-2].node), (yylsp[-2]), (yyvsp[0].list)); - } -#line 29396 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeIntervalNode((yyvsp[(3) - (5)].node), (yylsp[(3) - (5)]), (yyvsp[(5) - (5)].list)); + ;} break; - case 1262: /* AexprConst: ConstInterval Iconst opt_interval */ + case 1265: #line 4070 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeIntervalNode((yyvsp[-1].ival), (yylsp[-1]), (yyvsp[0].list)); - } -#line 29404 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeIntervalNode((yyvsp[(2) - (3)].ival), (yylsp[(2) - (3)]), (yyvsp[(3) - (3)].list)); + ;} break; - case 1263: /* AexprConst: ConstInterval Sconst opt_interval */ + case 1266: #line 4074 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeIntervalNode((yyvsp[-1].str), (yylsp[-1]), (yyvsp[0].list)); - } -#line 29412 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeIntervalNode((yyvsp[(2) - (3)].str), (yylsp[(2) - (3)]), (yyvsp[(3) - (3)].list)); + ;} break; - case 1264: /* AexprConst: TRUE_P */ + case 1267: #line 4078 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeBoolAConst(true, (yylsp[0])); - } -#line 29420 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeBoolAConst(true, (yylsp[(1) - (1)])); + ;} break; - case 1265: /* AexprConst: FALSE_P */ + case 1268: #line 4082 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeBoolAConst(false, (yylsp[0])); - } -#line 29428 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeBoolAConst(false, (yylsp[(1) - (1)])); + ;} break; - case 1266: /* AexprConst: NULL_P */ + case 1269: #line 4086 "third_party/libpg_query/grammar/statements/select.y" - { - (yyval.node) = makeNullAConst((yylsp[0])); - } -#line 29436 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeNullAConst((yylsp[(1) - (1)])); + ;} break; - case 1267: /* Iconst: ICONST */ + case 1270: #line 4091 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.ival) = (yyvsp[0].ival); } -#line 29442 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = (yyvsp[(1) - (1)].ival); ;} break; - case 1268: /* type_function_name: IDENT */ + case 1271: #line 4108 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (yyvsp[0].str); } -#line 29448 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1269: /* type_function_name: unreserved_keyword */ + case 1272: #line 4109 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = pstrdup((yyvsp[0].keyword)); } -#line 29454 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 1270: /* type_function_name: type_func_name_keyword */ + case 1273: #line 4110 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = pstrdup((yyvsp[0].keyword)); } -#line 29460 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 1271: /* function_name_token: IDENT */ + case 1274: #line 4113 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (yyvsp[0].str); } -#line 29466 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1272: /* function_name_token: unreserved_keyword */ + case 1275: #line 4114 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = pstrdup((yyvsp[0].keyword)); } -#line 29472 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 1273: /* function_name_token: func_name_keyword */ + case 1276: #line 4115 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = pstrdup((yyvsp[0].keyword)); } -#line 29478 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 1274: /* type_name_token: IDENT */ + case 1277: #line 4118 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (yyvsp[0].str); } -#line 29484 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1275: /* type_name_token: unreserved_keyword */ + case 1278: #line 4119 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = pstrdup((yyvsp[0].keyword)); } -#line 29490 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 1276: /* type_name_token: type_name_keyword */ + case 1279: #line 4120 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = pstrdup((yyvsp[0].keyword)); } -#line 29496 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 1277: /* any_name: ColId */ + case 1280: #line 4123 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString((yyvsp[0].str))); } -#line 29502 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; - case 1278: /* any_name: ColId attrs */ + case 1281: #line 4124 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lcons(makeString((yyvsp[-1].str)), (yyvsp[0].list)); } -#line 29508 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lcons(makeString((yyvsp[(1) - (2)].str)), (yyvsp[(2) - (2)].list)); ;} break; - case 1279: /* attrs: '.' attr_name */ + case 1282: #line 4128 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = list_make1(makeString((yyvsp[0].str))); } -#line 29514 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1(makeString((yyvsp[(2) - (2)].str))); ;} break; - case 1280: /* attrs: attrs '.' attr_name */ + case 1283: #line 4130 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = lappend((yyvsp[-2].list), makeString((yyvsp[0].str))); } -#line 29520 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), makeString((yyvsp[(3) - (3)].str))); ;} break; - case 1281: /* opt_name_list: '(' name_list_opt_comma ')' */ + case 1284: #line 4134 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 29526 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 1282: /* opt_name_list: %empty */ + case 1285: #line 4135 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.list) = NIL; } -#line 29532 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 1284: /* ColLabelOrString: ColLabel */ + case 1287: #line 4142 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (yyvsp[0].str); } -#line 29538 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1285: /* ColLabelOrString: SCONST */ + case 1288: #line 4143 "third_party/libpg_query/grammar/statements/select.y" - { (yyval.str) = (yyvsp[0].str); } -#line 29544 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1286: /* PrepareStmt: PREPARE name prep_type_clause AS PreparableStmt */ + case 1289: #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 29556 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1287: /* prep_type_clause: '(' type_list ')' */ + case 1290: #line 18 "third_party/libpg_query/grammar/statements/prepare.y" - { (yyval.list) = (yyvsp[-1].list); } -#line 29562 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 1288: /* prep_type_clause: %empty */ + case 1291: #line 19 "third_party/libpg_query/grammar/statements/prepare.y" - { (yyval.list) = NIL; } -#line 29568 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 1295: /* CreateSchemaStmt: CREATE_P SCHEMA qualified_name OptSchemaEltList */ + case 1298: #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 29591 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1296: /* CreateSchemaStmt: CREATE_P SCHEMA IF_P NOT EXISTS qualified_name OptSchemaEltList */ + case 1299: #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 29619 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1297: /* CreateSchemaStmt: CREATE_P OR REPLACE SCHEMA qualified_name OptSchemaEltList */ + case 1300: #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 29642 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1298: /* OptSchemaEltList: OptSchemaEltList schema_stmt */ + case 1301: #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 29652 "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 1299: /* OptSchemaEltList: %empty */ + case 1302: #line 80 "third_party/libpg_query/grammar/statements/create_schema.y" - { (yyval.list) = NIL; } -#line 29658 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 1304: /* IndexStmt: CREATE_P opt_unique INDEX opt_concurrently opt_index_name ON qualified_name access_method_clause '(' index_params ')' opt_reloptions where_clause */ + case 1307: #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; @@ -29680,22 +29535,21 @@ YYLTYPE yylloc = yyloc_default; n->transformed = false; n->onconflict = PG_ERROR_ON_CONFLICT; (yyval.node) = (PGNode *)n; - } -#line 29685 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1305: /* 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 1308: #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; @@ -29707,1615 +29561,1469 @@ YYLTYPE yylloc = yyloc_default; n->transformed = false; n->onconflict = PG_IGNORE_ON_CONFLICT; (yyval.node) = (PGNode *)n; - } -#line 29712 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1306: /* access_method: ColId */ + case 1309: #line 62 "third_party/libpg_query/grammar/statements/index.y" - { (yyval.str) = (yyvsp[0].str); } -#line 29718 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1307: /* access_method_clause: USING access_method */ + case 1310: #line 66 "third_party/libpg_query/grammar/statements/index.y" - { (yyval.str) = (yyvsp[0].str); } -#line 29724 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(2) - (2)].str); ;} break; - case 1308: /* access_method_clause: %empty */ + case 1311: #line 67 "third_party/libpg_query/grammar/statements/index.y" - { (yyval.str) = (char*) DEFAULT_INDEX_TYPE; } -#line 29730 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (char*) DEFAULT_INDEX_TYPE; ;} break; - case 1309: /* opt_concurrently: CONCURRENTLY */ + case 1312: #line 72 "third_party/libpg_query/grammar/statements/index.y" - { (yyval.boolean) = true; } -#line 29736 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = true; ;} break; - case 1310: /* opt_concurrently: %empty */ + case 1313: #line 73 "third_party/libpg_query/grammar/statements/index.y" - { (yyval.boolean) = false; } -#line 29742 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = false; ;} break; - case 1311: /* opt_index_name: index_name */ + case 1314: #line 78 "third_party/libpg_query/grammar/statements/index.y" - { (yyval.str) = (yyvsp[0].str); } -#line 29748 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1312: /* opt_index_name: %empty */ + case 1315: #line 79 "third_party/libpg_query/grammar/statements/index.y" - { (yyval.str) = NULL; } -#line 29754 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = NULL; ;} break; - case 1313: /* opt_reloptions: WITH reloptions */ + case 1316: #line 83 "third_party/libpg_query/grammar/statements/index.y" - { (yyval.list) = (yyvsp[0].list); } -#line 29760 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (2)].list); ;} break; - case 1314: /* opt_reloptions: %empty */ + case 1317: #line 84 "third_party/libpg_query/grammar/statements/index.y" - { (yyval.list) = NIL; } -#line 29766 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 1315: /* opt_unique: UNIQUE */ + case 1318: #line 89 "third_party/libpg_query/grammar/statements/index.y" - { (yyval.boolean) = true; } -#line 29772 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = true; ;} break; - case 1316: /* opt_unique: %empty */ + case 1319: #line 90 "third_party/libpg_query/grammar/statements/index.y" - { (yyval.boolean) = false; } -#line 29778 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = false; ;} break; - case 1317: /* AlterObjectSchemaStmt: ALTER TABLE relation_expr SET SCHEMA name */ + case 1320: #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 29791 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1318: /* AlterObjectSchemaStmt: ALTER TABLE IF_P EXISTS relation_expr SET SCHEMA name */ + case 1321: #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 29804 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1319: /* AlterObjectSchemaStmt: ALTER SEQUENCE qualified_name SET SCHEMA name */ + case 1322: #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 29817 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1320: /* AlterObjectSchemaStmt: ALTER SEQUENCE IF_P EXISTS qualified_name SET SCHEMA name */ + case 1323: #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 29830 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1321: /* AlterObjectSchemaStmt: ALTER VIEW qualified_name SET SCHEMA name */ + case 1324: #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 29843 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1322: /* AlterObjectSchemaStmt: ALTER VIEW IF_P EXISTS qualified_name SET SCHEMA name */ + case 1325: #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 29856 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1323: /* CheckPointStmt: FORCE CHECKPOINT opt_col_id */ + case 1326: #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 29867 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1324: /* CheckPointStmt: CHECKPOINT opt_col_id */ + case 1327: #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 29878 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1325: /* opt_col_id: ColId */ + case 1328: #line 22 "third_party/libpg_query/grammar/statements/checkpoint.y" - { (yyval.str) = (yyvsp[0].str); } -#line 29884 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1326: /* opt_col_id: %empty */ + case 1329: #line 23 "third_party/libpg_query/grammar/statements/checkpoint.y" - { (yyval.str) = NULL; } -#line 29890 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = NULL; ;} break; - case 1327: /* CommentOnStmt: COMMENT ON comment_on_type_any_name qualified_name IS comment_value */ + case 1330: #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 29902 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1328: /* CommentOnStmt: COMMENT ON COLUMN a_expr IS comment_value */ + case 1331: #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 29914 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1329: /* comment_value: Sconst */ + case 1332: #line 26 "third_party/libpg_query/grammar/statements/comment_on.y" - { (yyval.node) = makeStringConst((yyvsp[0].str), (yylsp[0])); } -#line 29920 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = makeStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); ;} break; - case 1330: /* comment_value: NULL_P */ + case 1333: #line 27 "third_party/libpg_query/grammar/statements/comment_on.y" - { (yyval.node) = makeNullAConst((yylsp[0])); } -#line 29926 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = makeNullAConst((yylsp[(1) - (1)])); ;} break; - case 1331: /* comment_on_type_any_name: TABLE */ + case 1334: #line 30 "third_party/libpg_query/grammar/statements/comment_on.y" - { (yyval.objtype) = PG_OBJECT_TABLE; } -#line 29932 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_TABLE; ;} break; - case 1332: /* comment_on_type_any_name: SEQUENCE */ + case 1335: #line 31 "third_party/libpg_query/grammar/statements/comment_on.y" - { (yyval.objtype) = PG_OBJECT_SEQUENCE; } -#line 29938 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_SEQUENCE; ;} break; - case 1333: /* comment_on_type_any_name: FUNCTION */ + case 1336: #line 32 "third_party/libpg_query/grammar/statements/comment_on.y" - { (yyval.objtype) = PG_OBJECT_FUNCTION; } -#line 29944 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_FUNCTION; ;} break; - case 1334: /* comment_on_type_any_name: MACRO */ + case 1337: #line 33 "third_party/libpg_query/grammar/statements/comment_on.y" - { (yyval.objtype) = PG_OBJECT_FUNCTION; } -#line 29950 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_FUNCTION; ;} break; - case 1335: /* comment_on_type_any_name: MACRO TABLE */ + case 1338: #line 34 "third_party/libpg_query/grammar/statements/comment_on.y" - { (yyval.objtype) = PG_OBJECT_TABLE_MACRO; } -#line 29956 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_TABLE_MACRO; ;} break; - case 1336: /* comment_on_type_any_name: VIEW */ + case 1339: #line 35 "third_party/libpg_query/grammar/statements/comment_on.y" - { (yyval.objtype) = PG_OBJECT_VIEW; } -#line 29962 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_VIEW; ;} break; - case 1337: /* comment_on_type_any_name: DATABASE */ + case 1340: #line 36 "third_party/libpg_query/grammar/statements/comment_on.y" - { (yyval.objtype) = PG_OBJECT_DATABASE; } -#line 29968 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_DATABASE; ;} break; - case 1338: /* comment_on_type_any_name: INDEX */ + case 1341: #line 37 "third_party/libpg_query/grammar/statements/comment_on.y" - { (yyval.objtype) = PG_OBJECT_INDEX; } -#line 29974 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_INDEX; ;} break; - case 1339: /* comment_on_type_any_name: SCHEMA */ + case 1342: #line 38 "third_party/libpg_query/grammar/statements/comment_on.y" - { (yyval.objtype) = PG_OBJECT_SCHEMA; } -#line 29980 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_SCHEMA; ;} break; - case 1340: /* comment_on_type_any_name: TYPE_P */ + case 1343: #line 39 "third_party/libpg_query/grammar/statements/comment_on.y" - { (yyval.objtype) = PG_OBJECT_TYPE; } -#line 29986 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.objtype) = PG_OBJECT_TYPE; ;} break; - case 1341: /* ExportStmt: EXPORT_P DATABASE Sconst copy_options */ + case 1344: #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 30001 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1342: /* ExportStmt: EXPORT_P DATABASE ColId TO Sconst copy_options */ + case 1345: #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 30016 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1343: /* ImportStmt: IMPORT_P DATABASE Sconst */ + case 1346: #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 30026 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1344: /* ExplainStmt: EXPLAIN ExplainableStmt */ + case 1347: #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 30037 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1345: /* ExplainStmt: EXPLAIN analyze_keyword opt_verbose ExplainableStmt */ + case 1348: #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 30051 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1346: /* ExplainStmt: EXPLAIN VERBOSE ExplainableStmt */ + case 1349: #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 30062 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1347: /* ExplainStmt: EXPLAIN '(' explain_option_list ')' ExplainableStmt */ + case 1350: #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 30073 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1348: /* opt_verbose: VERBOSE */ + case 1351: #line 44 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.boolean) = true; } -#line 30079 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = true; ;} break; - case 1349: /* opt_verbose: %empty */ + case 1352: #line 45 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.boolean) = false; } -#line 30085 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = false; ;} break; - case 1350: /* explain_option_arg: opt_boolean_or_string */ + case 1353: #line 50 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.node) = (PGNode *) makeString((yyvsp[0].str)); } -#line 30091 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) makeString((yyvsp[(1) - (1)].str)); ;} break; - case 1351: /* explain_option_arg: NumericOnly */ + case 1354: #line 51 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.node) = (PGNode *) (yyvsp[0].value); } -#line 30097 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (PGNode *) (yyvsp[(1) - (1)].value); ;} break; - case 1352: /* explain_option_arg: %empty */ + case 1355: #line 52 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.node) = NULL; } -#line 30103 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = NULL; ;} break; - case 1384: /* NonReservedWord: IDENT */ + case 1387: #line 91 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.str) = (yyvsp[0].str); } -#line 30109 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1385: /* NonReservedWord: unreserved_keyword */ + case 1388: #line 92 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.str) = pstrdup((yyvsp[0].keyword)); } -#line 30115 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 1386: /* NonReservedWord: other_keyword */ + case 1389: #line 93 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.str) = pstrdup((yyvsp[0].keyword)); } -#line 30121 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 1387: /* NonReservedWord_or_Sconst: NonReservedWord */ + case 1390: #line 98 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.str) = (yyvsp[0].str); } -#line 30127 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1388: /* NonReservedWord_or_Sconst: Sconst */ + case 1391: #line 99 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.str) = (yyvsp[0].str); } -#line 30133 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1389: /* explain_option_list: explain_option_elem */ + case 1392: #line 105 "third_party/libpg_query/grammar/statements/explain.y" - { - (yyval.list) = list_make1((yyvsp[0].defelt)); - } -#line 30141 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); + ;} break; - case 1390: /* explain_option_list: explain_option_list ',' explain_option_elem */ + case 1393: #line 109 "third_party/libpg_query/grammar/statements/explain.y" - { - (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].defelt)); - } -#line 30149 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt)); + ;} break; - case 1391: /* analyze_keyword: ANALYZE */ + case 1394: #line 116 "third_party/libpg_query/grammar/statements/explain.y" - {} -#line 30155 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 1392: /* analyze_keyword: ANALYSE */ + case 1395: #line 117 "third_party/libpg_query/grammar/statements/explain.y" - {} -#line 30161 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 1393: /* opt_boolean_or_string: TRUE_P */ + case 1396: #line 122 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.str) = (char*) "true"; } -#line 30167 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (char*) "true"; ;} break; - case 1394: /* opt_boolean_or_string: FALSE_P */ + case 1397: #line 123 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.str) = (char*) "false"; } -#line 30173 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (char*) "false"; ;} break; - case 1395: /* opt_boolean_or_string: ON */ + case 1398: #line 124 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.str) = (char*) "on"; } -#line 30179 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (char*) "on"; ;} break; - case 1396: /* opt_boolean_or_string: NonReservedWord_or_Sconst */ + case 1399: #line 130 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.str) = (yyvsp[0].str); } -#line 30185 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1397: /* explain_option_elem: explain_option_name explain_option_arg */ + case 1400: #line 136 "third_party/libpg_query/grammar/statements/explain.y" - { - (yyval.defelt) = makeDefElem((yyvsp[-1].str), (yyvsp[0].node), (yylsp[-1])); - } -#line 30193 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.defelt) = makeDefElem((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); + ;} break; - case 1398: /* explain_option_name: NonReservedWord */ + case 1401: #line 143 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.str) = (yyvsp[0].str); } -#line 30199 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1399: /* explain_option_name: analyze_keyword */ + case 1402: #line 144 "third_party/libpg_query/grammar/statements/explain.y" - { (yyval.str) = (char*) "analyze"; } -#line 30205 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (char*) "analyze"; ;} break; - case 1400: /* VariableSetStmt: SET set_rest */ + case 1403: #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 30215 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1401: /* VariableSetStmt: SET LOCAL set_rest */ + case 1404: #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 30225 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1402: /* VariableSetStmt: SET SESSION set_rest */ + case 1405: #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 30235 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1403: /* VariableSetStmt: SET GLOBAL set_rest */ + case 1406: #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 30245 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1404: /* set_rest: generic_set */ + case 1407: #line 38 "third_party/libpg_query/grammar/statements/variable_set.y" - {(yyval.vsetstmt) = (yyvsp[0].vsetstmt);} -#line 30251 "third_party/libpg_query/grammar/grammar_out.cpp" + {(yyval.vsetstmt) = (yyvsp[(1) - (1)].vsetstmt);;} break; - case 1405: /* set_rest: var_name FROM CURRENT_P */ + case 1408: #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 30262 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1406: /* set_rest: TIME ZONE zone_value */ + case 1409: #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 30277 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1407: /* set_rest: SCHEMA Sconst */ + case 1410: #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 30289 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1408: /* generic_set: var_name TO var_list */ + case 1411: #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 30301 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1409: /* generic_set: var_name '=' var_list */ + case 1412: #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 30313 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1410: /* var_value: a_expr */ + case 1413: #line 90 "third_party/libpg_query/grammar/statements/variable_set.y" - { (yyval.node) = (yyvsp[0].node); } -#line 30319 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 1411: /* zone_value: Sconst */ + case 1414: #line 96 "third_party/libpg_query/grammar/statements/variable_set.y" - { - (yyval.node) = makeStringConst((yyvsp[0].str), (yylsp[0])); - } -#line 30327 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); + ;} break; - case 1412: /* zone_value: IDENT */ + case 1415: #line 100 "third_party/libpg_query/grammar/statements/variable_set.y" - { - (yyval.node) = makeStringConst((yyvsp[0].str), (yylsp[0])); - } -#line 30335 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.node) = makeStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); + ;} break; - case 1413: /* zone_value: ConstInterval Sconst opt_interval */ + case 1416: #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 30354 "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 1414: /* zone_value: ConstInterval '(' Iconst ')' Sconst */ + case 1417: #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 30365 "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 1415: /* zone_value: NumericOnly */ + case 1418: #line 125 "third_party/libpg_query/grammar/statements/variable_set.y" - { (yyval.node) = makeAConst((yyvsp[0].value), (yylsp[0])); } -#line 30371 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = makeAConst((yyvsp[(1) - (1)].value), (yylsp[(1) - (1)])); ;} break; - case 1416: /* zone_value: DEFAULT */ + case 1419: #line 126 "third_party/libpg_query/grammar/statements/variable_set.y" - { (yyval.node) = NULL; } -#line 30377 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = NULL; ;} break; - case 1417: /* zone_value: LOCAL */ + case 1420: #line 127 "third_party/libpg_query/grammar/statements/variable_set.y" - { (yyval.node) = NULL; } -#line 30383 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = NULL; ;} break; - case 1418: /* var_list: var_value */ + case 1421: #line 131 "third_party/libpg_query/grammar/statements/variable_set.y" - { (yyval.list) = list_make1((yyvsp[0].node)); } -#line 30389 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 1419: /* var_list: var_list ',' var_value */ + case 1422: #line 132 "third_party/libpg_query/grammar/statements/variable_set.y" - { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].node)); } -#line 30395 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; - case 1420: /* LoadStmt: LOAD file_name */ + case 1423: #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 = NULL; n->repo_is_alias = false; n->version = NULL; n->load_type = PG_LOAD_TYPE_LOAD; (yyval.node) = (PGNode *)n; - } -#line 30409 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1421: /* LoadStmt: opt_force INSTALL file_name opt_ext_version */ + case 1424: #line 17 "third_party/libpg_query/grammar/statements/load.y" - { + { PGLoadStmt *n = makeNode(PGLoadStmt); - n->filename = (yyvsp[-1].str); + n->filename = (yyvsp[(3) - (4)].str); n->repository = NULL; n->repo_is_alias = false; - n->version = (yyvsp[0].str); - n->load_type = (yyvsp[-3].loadinstalltype); + n->version = (yyvsp[(4) - (4)].str); + n->load_type = (yyvsp[(1) - (4)].loadinstalltype); (yyval.node) = (PGNode *)n; - } -#line 30423 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1422: /* LoadStmt: opt_force INSTALL file_name FROM ColId opt_ext_version */ + case 1425: #line 26 "third_party/libpg_query/grammar/statements/load.y" - { + { PGLoadStmt *n = makeNode(PGLoadStmt); - n->repository = (yyvsp[-1].str); + n->repository = (yyvsp[(5) - (6)].str); n->repo_is_alias = true; - n->filename = (yyvsp[-3].str); - n->version = (yyvsp[0].str); - n->load_type = (yyvsp[-5].loadinstalltype); + n->filename = (yyvsp[(3) - (6)].str); + n->version = (yyvsp[(6) - (6)].str); + n->load_type = (yyvsp[(1) - (6)].loadinstalltype); (yyval.node) = (PGNode *)n; - } -#line 30437 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1423: /* LoadStmt: opt_force INSTALL file_name FROM Sconst opt_ext_version */ + case 1426: #line 35 "third_party/libpg_query/grammar/statements/load.y" - { + { PGLoadStmt *n = makeNode(PGLoadStmt); - n->filename = (yyvsp[-3].str); - n->repository = (yyvsp[-1].str); + n->filename = (yyvsp[(3) - (6)].str); + n->repository = (yyvsp[(5) - (6)].str); n->repo_is_alias = false; - n->version = (yyvsp[0].str); - n->load_type = (yyvsp[-5].loadinstalltype); + n->version = (yyvsp[(6) - (6)].str); + n->load_type = (yyvsp[(1) - (6)].loadinstalltype); (yyval.node) = (PGNode *)n; - } -#line 30451 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1424: /* opt_force: %empty */ + case 1427: #line 46 "third_party/libpg_query/grammar/statements/load.y" - { (yyval.loadinstalltype) = PG_LOAD_TYPE_INSTALL; } -#line 30457 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.loadinstalltype) = PG_LOAD_TYPE_INSTALL; ;} break; - case 1425: /* opt_force: FORCE */ + case 1428: #line 47 "third_party/libpg_query/grammar/statements/load.y" - { (yyval.loadinstalltype) = PG_LOAD_TYPE_FORCE_INSTALL; } -#line 30463 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.loadinstalltype) = PG_LOAD_TYPE_FORCE_INSTALL; ;} break; - case 1426: /* file_name: Sconst */ + case 1429: #line 49 "third_party/libpg_query/grammar/statements/load.y" - { (yyval.str) = (yyvsp[0].str); } -#line 30469 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1427: /* file_name: ColId */ + case 1430: #line 50 "third_party/libpg_query/grammar/statements/load.y" - { (yyval.str) = (yyvsp[0].str); } -#line 30475 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1428: /* opt_ext_version: %empty */ + case 1431: #line 53 "third_party/libpg_query/grammar/statements/load.y" - { (yyval.str) = NULL; } -#line 30481 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = NULL; ;} break; - case 1429: /* opt_ext_version: VERSION_P Sconst */ + case 1432: #line 54 "third_party/libpg_query/grammar/statements/load.y" - { (yyval.str) = (yyvsp[0].str); } -#line 30487 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(2) - (2)].str); ;} break; - case 1430: /* opt_ext_version: VERSION_P ColId */ + case 1433: #line 55 "third_party/libpg_query/grammar/statements/load.y" - { (yyval.str) = (yyvsp[0].str); } -#line 30493 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(2) - (2)].str); ;} break; - case 1431: /* VacuumStmt: VACUUM opt_full opt_freeze opt_verbose */ + case 1434: #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 30511 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1432: /* VacuumStmt: VACUUM opt_full opt_freeze opt_verbose qualified_name opt_name_list */ + case 1435: #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 30529 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1433: /* VacuumStmt: VACUUM opt_full opt_freeze opt_verbose AnalyzeStmt */ + case 1436: #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 30545 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1434: /* VacuumStmt: VACUUM '(' vacuum_option_list ')' */ + case 1437: #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 30557 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1435: /* VacuumStmt: VACUUM '(' vacuum_option_list ')' qualified_name opt_name_list */ + case 1438: #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 30571 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1436: /* vacuum_option_elem: analyze_keyword */ + case 1439: #line 70 "third_party/libpg_query/grammar/statements/vacuum.y" - { (yyval.ival) = PG_VACOPT_ANALYZE; } -#line 30577 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_VACOPT_ANALYZE; ;} break; - case 1437: /* vacuum_option_elem: VERBOSE */ + case 1440: #line 71 "third_party/libpg_query/grammar/statements/vacuum.y" - { (yyval.ival) = PG_VACOPT_VERBOSE; } -#line 30583 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_VACOPT_VERBOSE; ;} break; - case 1438: /* vacuum_option_elem: FREEZE */ + case 1441: #line 72 "third_party/libpg_query/grammar/statements/vacuum.y" - { (yyval.ival) = PG_VACOPT_FREEZE; } -#line 30589 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_VACOPT_FREEZE; ;} break; - case 1439: /* vacuum_option_elem: FULL */ + case 1442: #line 73 "third_party/libpg_query/grammar/statements/vacuum.y" - { (yyval.ival) = PG_VACOPT_FULL; } -#line 30595 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = PG_VACOPT_FULL; ;} break; - case 1440: /* vacuum_option_elem: IDENT */ + case 1443: #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 30609 "third_party/libpg_query/grammar/grammar_out.cpp" + errmsg("unrecognized VACUUM option \"%s\"", (yyvsp[(1) - (1)].str)), + parser_errposition((yylsp[(1) - (1)])))); + ;} break; - case 1441: /* opt_full: FULL */ + case 1444: #line 87 "third_party/libpg_query/grammar/statements/vacuum.y" - { (yyval.boolean) = true; } -#line 30615 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = true; ;} break; - case 1442: /* opt_full: %empty */ + case 1445: #line 88 "third_party/libpg_query/grammar/statements/vacuum.y" - { (yyval.boolean) = false; } -#line 30621 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = false; ;} break; - case 1443: /* vacuum_option_list: vacuum_option_elem */ + case 1446: #line 93 "third_party/libpg_query/grammar/statements/vacuum.y" - { (yyval.ival) = (yyvsp[0].ival); } -#line 30627 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = (yyvsp[(1) - (1)].ival); ;} break; - case 1444: /* vacuum_option_list: vacuum_option_list ',' vacuum_option_elem */ + case 1447: #line 94 "third_party/libpg_query/grammar/statements/vacuum.y" - { (yyval.ival) = (yyvsp[-2].ival) | (yyvsp[0].ival); } -#line 30633 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.ival) = (yyvsp[(1) - (3)].ival) | (yyvsp[(3) - (3)].ival); ;} break; - case 1445: /* opt_freeze: FREEZE */ + case 1448: #line 98 "third_party/libpg_query/grammar/statements/vacuum.y" - { (yyval.boolean) = true; } -#line 30639 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = true; ;} break; - case 1446: /* opt_freeze: %empty */ + case 1449: #line 99 "third_party/libpg_query/grammar/statements/vacuum.y" - { (yyval.boolean) = false; } -#line 30645 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = false; ;} break; - case 1447: /* DeleteStmt: opt_with_clause DELETE_P FROM relation_expr_opt_alias using_clause where_or_current_clause returning_clause */ + case 1450: #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 30659 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1448: /* DeleteStmt: TRUNCATE opt_table relation_expr_opt_alias */ + case 1451: #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 30673 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1449: /* relation_expr_opt_alias: relation_expr */ + case 1452: #line 32 "third_party/libpg_query/grammar/statements/delete.y" - { - (yyval.range) = (yyvsp[0].range); - } -#line 30681 "third_party/libpg_query/grammar/grammar_out.cpp" + { + (yyval.range) = (yyvsp[(1) - (1)].range); + ;} break; - case 1450: /* relation_expr_opt_alias: relation_expr ColId */ + case 1453: #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 30692 "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 1451: /* relation_expr_opt_alias: relation_expr AS ColId */ + case 1454: #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 30703 "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 1452: /* where_or_current_clause: WHERE a_expr */ + case 1455: #line 53 "third_party/libpg_query/grammar/statements/delete.y" - { (yyval.node) = (yyvsp[0].node); } -#line 30709 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 1453: /* where_or_current_clause: %empty */ + case 1456: #line 54 "third_party/libpg_query/grammar/statements/delete.y" - { (yyval.node) = NULL; } -#line 30715 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.node) = NULL; ;} break; - case 1454: /* using_clause: USING from_list_opt_comma */ + case 1457: #line 60 "third_party/libpg_query/grammar/statements/delete.y" - { (yyval.list) = (yyvsp[0].list); } -#line 30721 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = (yyvsp[(2) - (2)].list); ;} break; - case 1455: /* using_clause: %empty */ + case 1458: #line 61 "third_party/libpg_query/grammar/statements/delete.y" - { (yyval.list) = NIL; } -#line 30727 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.list) = NIL; ;} break; - case 1456: /* AnalyzeStmt: analyze_keyword opt_verbose */ + case 1459: #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 30741 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1457: /* AnalyzeStmt: analyze_keyword opt_verbose qualified_name opt_name_list */ + case 1460: #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 30755 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1458: /* AttachStmt: ATTACH opt_database Sconst opt_database_alias copy_options */ + case 1461: #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 30768 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1459: /* AttachStmt: ATTACH IF_P NOT EXISTS opt_database Sconst opt_database_alias copy_options */ + case 1462: #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 30781 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1460: /* DetachStmt: DETACH ColLabel */ + case 1463: #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 30792 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1461: /* DetachStmt: DETACH DATABASE ColLabel */ + case 1464: #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 30803 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1462: /* DetachStmt: DETACH DATABASE IF_P EXISTS ColLabel */ + case 1465: #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 30814 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1463: /* opt_database: DATABASE */ + case 1466: #line 51 "third_party/libpg_query/grammar/statements/attach.y" - {} -#line 30820 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 1464: /* opt_database: %empty */ + case 1467: #line 52 "third_party/libpg_query/grammar/statements/attach.y" - {} -#line 30826 "third_party/libpg_query/grammar/grammar_out.cpp" + {;} break; - case 1465: /* opt_database_alias: AS ColId */ + case 1468: #line 56 "third_party/libpg_query/grammar/statements/attach.y" - { (yyval.str) = (yyvsp[0].str); } -#line 30832 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(2) - (2)].str); ;} break; - case 1466: /* opt_database_alias: %empty */ + case 1469: #line 57 "third_party/libpg_query/grammar/statements/attach.y" - { (yyval.str) = NULL; } -#line 30838 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = NULL; ;} break; - case 1467: /* VariableResetStmt: RESET reset_rest */ + case 1470: #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 30847 "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 1468: /* VariableResetStmt: RESET LOCAL reset_rest */ + case 1471: #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 30856 "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 1469: /* VariableResetStmt: RESET SESSION reset_rest */ + case 1472: #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 30865 "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 1470: /* VariableResetStmt: RESET GLOBAL reset_rest */ + case 1473: #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 30874 "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 1471: /* generic_reset: var_name */ + case 1474: #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 30885 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1472: /* generic_reset: ALL */ + case 1475: #line 34 "third_party/libpg_query/grammar/statements/variable_reset.y" - { + { PGVariableSetStmt *n = makeNode(PGVariableSetStmt); n->kind = VAR_RESET_ALL; (yyval.vsetstmt) = n; - } -#line 30895 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1473: /* reset_rest: generic_reset */ + case 1476: #line 43 "third_party/libpg_query/grammar/statements/variable_reset.y" - { (yyval.vsetstmt) = (yyvsp[0].vsetstmt); } -#line 30901 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.vsetstmt) = (yyvsp[(1) - (1)].vsetstmt); ;} break; - case 1474: /* reset_rest: TIME ZONE */ + case 1477: #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 30912 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1475: /* reset_rest: TRANSACTION ISOLATION LEVEL */ + case 1478: #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 30923 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1476: /* VariableShowStmt: show_or_describe SelectStmt */ + case 1479: #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 30935 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1477: /* VariableShowStmt: SUMMARIZE SelectStmt */ + case 1480: #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 30947 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1478: /* VariableShowStmt: SUMMARIZE table_id */ + case 1481: #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 30958 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1479: /* VariableShowStmt: show_or_describe table_id */ + case 1482: #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 30969 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1480: /* VariableShowStmt: show_or_describe TIME ZONE */ + case 1483: #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 30980 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1481: /* VariableShowStmt: show_or_describe TRANSACTION ISOLATION LEVEL */ + case 1484: #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 30991 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1482: /* VariableShowStmt: show_or_describe ALL opt_tables */ + case 1485: #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 31002 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1483: /* VariableShowStmt: show_or_describe */ + case 1486: #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 31013 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1490: /* var_name: ColId */ + case 1493: #line 67 "third_party/libpg_query/grammar/statements/variable_show.y" - { (yyval.str) = (yyvsp[0].str); } -#line 31019 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1491: /* var_name: var_name '.' ColId */ + case 1494: #line 69 "third_party/libpg_query/grammar/statements/variable_show.y" - { (yyval.str) = psprintf("%s.%s", (yyvsp[-2].str), (yyvsp[0].str)); } -#line 31025 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = psprintf("%s.%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)); ;} break; - case 1492: /* table_id: ColId */ + case 1495: #line 72 "third_party/libpg_query/grammar/statements/variable_show.y" - { (yyval.str) = psprintf("\"%s\"", (yyvsp[0].str)); } -#line 31031 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = psprintf("\"%s\"", (yyvsp[(1) - (1)].str)); ;} break; - case 1493: /* table_id: table_id '.' ColId */ + case 1496: #line 74 "third_party/libpg_query/grammar/statements/variable_show.y" - { (yyval.str) = psprintf("%s.\"%s\"", (yyvsp[-2].str), (yyvsp[0].str)); } -#line 31037 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.str) = psprintf("%s.\"%s\"", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)); ;} break; - case 1494: /* CallStmt: CALL_P func_application */ + case 1497: #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 31047 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1495: /* ViewStmt: CREATE_P OptTemp VIEW qualified_name opt_column_list opt_reloptions AS SelectStmt opt_check_option */ + case 1498: #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 31063 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1496: /* ViewStmt: CREATE_P OptTemp VIEW IF_P NOT EXISTS qualified_name opt_column_list opt_reloptions AS SelectStmt opt_check_option */ + case 1499: #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 31079 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1497: /* ViewStmt: CREATE_P OR REPLACE OptTemp VIEW qualified_name opt_column_list opt_reloptions AS SelectStmt opt_check_option */ + case 1500: #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 31095 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1498: /* ViewStmt: CREATE_P OptTemp RECURSIVE VIEW qualified_name '(' columnList ')' opt_reloptions AS SelectStmt opt_check_option */ + case 1501: #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 31116 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1499: /* ViewStmt: CREATE_P OR REPLACE OptTemp RECURSIVE VIEW qualified_name '(' columnList ')' opt_reloptions AS SelectStmt opt_check_option */ + case 1502: #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 31137 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1500: /* opt_check_option: WITH CHECK_P OPTION */ + case 1503: #line 87 "third_party/libpg_query/grammar/statements/view.y" - { (yyval.viewcheckoption) = CASCADED_CHECK_OPTION; } -#line 31143 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.viewcheckoption) = CASCADED_CHECK_OPTION; ;} break; - case 1501: /* opt_check_option: WITH CASCADED CHECK_P OPTION */ + case 1504: #line 88 "third_party/libpg_query/grammar/statements/view.y" - { (yyval.viewcheckoption) = CASCADED_CHECK_OPTION; } -#line 31149 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.viewcheckoption) = CASCADED_CHECK_OPTION; ;} break; - case 1502: /* opt_check_option: WITH LOCAL CHECK_P OPTION */ + case 1505: #line 89 "third_party/libpg_query/grammar/statements/view.y" - { (yyval.viewcheckoption) = PG_LOCAL_CHECK_OPTION; } -#line 31155 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.viewcheckoption) = PG_LOCAL_CHECK_OPTION; ;} break; - case 1503: /* opt_check_option: %empty */ + case 1506: #line 90 "third_party/libpg_query/grammar/statements/view.y" - { (yyval.viewcheckoption) = PG_NO_CHECK_OPTION; } -#line 31161 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.viewcheckoption) = PG_NO_CHECK_OPTION; ;} break; - case 1504: /* CreateAsStmt: CREATE_P OptTemp TABLE create_as_target AS SelectStmt opt_with_data */ + case 1507: #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 31178 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1505: /* CreateAsStmt: CREATE_P OptTemp TABLE IF_P NOT EXISTS create_as_target AS SelectStmt opt_with_data */ + case 1508: #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 31195 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1506: /* CreateAsStmt: CREATE_P OR REPLACE OptTemp TABLE create_as_target AS SelectStmt opt_with_data */ + case 1509: #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 31212 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; - case 1507: /* opt_with_data: WITH DATA_P */ + case 1510: #line 54 "third_party/libpg_query/grammar/statements/create_as.y" - { (yyval.boolean) = true; } -#line 31218 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = true; ;} break; - case 1508: /* opt_with_data: WITH NO DATA_P */ + case 1511: #line 55 "third_party/libpg_query/grammar/statements/create_as.y" - { (yyval.boolean) = false; } -#line 31224 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = false; ;} break; - case 1509: /* opt_with_data: %empty */ + case 1512: #line 56 "third_party/libpg_query/grammar/statements/create_as.y" - { (yyval.boolean) = true; } -#line 31230 "third_party/libpg_query/grammar/grammar_out.cpp" + { (yyval.boolean) = true; ;} break; - case 1510: /* create_as_target: qualified_name opt_column_list OptWith OnCommitOption */ + case 1513: #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 31244 "third_party/libpg_query/grammar/grammar_out.cpp" + ;} break; -#line 31248 "third_party/libpg_query/grammar/grammar_out.cpp" - +/* Line 1267 of yacc.c. */ +#line 30934 "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; @@ -31324,13 +31032,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; @@ -31343,45 +31053,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; @@ -31392,56 +31104,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" @@ -32199,3 +31907,4 @@ parser_init(base_yy_extra_type *yyext) #undef yylloc } // namespace duckdb_libpgquery + diff --git a/third_party/re2/re2/prog.cc b/third_party/re2/re2/prog.cc index 92c54f8abb7..716b6f3eef7 100644 --- a/third_party/re2/re2/prog.cc +++ b/third_party/re2/re2/prog.cc @@ -1143,8 +1143,8 @@ const void* Prog::PrefixAccel_FrontAndBack(const void* data, size_t size) { const __m256i* bp = reinterpret_cast( reinterpret_cast(data) + prefix_size_-1); const __m256i* endfp = fp + size/sizeof(__m256i); - const __m256i f_set1 = _mm256_set1_epi8(prefix_front_); - const __m256i b_set1 = _mm256_set1_epi8(prefix_back_); + const __m256i f_set1 = _mm256_set1_epi8(prefix_front_back.prefix_front_); + const __m256i b_set1 = _mm256_set1_epi8(prefix_front_back.prefix_back_); do { const __m256i f_loadu = _mm256_loadu_si256(fp++); const __m256i b_loadu = _mm256_loadu_si256(bp++); diff --git a/third_party/utf8proc/include/utf8proc.hpp b/third_party/utf8proc/include/utf8proc.hpp index 37fa1f2664b..5d66c15d3d9 100644 --- a/third_party/utf8proc/include/utf8proc.hpp +++ b/third_party/utf8proc/include/utf8proc.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2014-2019 Steven G. Johnson, Jiahao Chen, Peter Colberg, Tony Kelman, Scott P. Jones, and other contributors. + * Copyright (c) 2014-2021 Steven G. Johnson, Jiahao Chen, Peter Colberg, Tony Kelman, Scott P. Jones, and other contributors. * Copyright (c) 2009 Public Software Group e. V., Berlin, Germany * * Permission is hereby granted, free of charge, to any person obtaining a @@ -36,16 +36,16 @@ * * The features of utf8proc include: * - * - Transformation of strings (@ref utf8proc_map) to: + * - Transformation of strings (utf8proc_map()) to: * - decompose (@ref UTF8PROC_DECOMPOSE) or compose (@ref UTF8PROC_COMPOSE) Unicode combining characters (http://en.wikipedia.org/wiki/Combining_character) * - canonicalize Unicode compatibility characters (@ref UTF8PROC_COMPAT) * - strip "ignorable" (@ref UTF8PROC_IGNORE) characters, control characters (@ref UTF8PROC_STRIPCC), or combining characters such as accents (@ref UTF8PROC_STRIPMARK) * - case-folding (@ref UTF8PROC_CASEFOLD) - * - Unicode normalization: @ref utf8proc_NFD, @ref utf8proc_NFC, @ref utf8proc_NFKD, @ref utf8proc_NFKC - * - Detecting grapheme boundaries (@ref utf8proc_grapheme_break and @ref UTF8PROC_CHARBOUND) - * - Character-width computation: @ref utf8proc_charwidth - * - Classification of characters by Unicode category: @ref utf8proc_category and @ref utf8proc_category_string - * - Encode (@ref utf8proc_encode_char) and decode (@ref utf8proc_iterate) Unicode codepoints to/from UTF-8. + * - Unicode normalization: utf8proc_NFD(), utf8proc_NFC(), utf8proc_NFKD(), utf8proc_NFKC() + * - Detecting grapheme boundaries (utf8proc_grapheme_break() and @ref UTF8PROC_CHARBOUND) + * - Character-width computation: utf8proc_charwidth() + * - Classification of characters by Unicode category: utf8proc_category() and utf8proc_category_string() + * - Encode (utf8proc_encode_char()) and decode (utf8proc_iterate()) Unicode codepoints to/from UTF-8. */ /** @file */ @@ -53,16 +53,13 @@ #ifndef UTF8PROC_H #define UTF8PROC_H -// DuckDB change: -#define UTF8PROC_STATIC - /** @name API version * * The utf8proc API version MAJOR.MINOR.PATCH, following * semantic-versioning rules (http://semver.org) based on API * compatibility. * - * This is also returned at runtime by @ref utf8proc_version; however, the + * This is also returned at runtime by utf8proc_version(); however, the * runtime version may append a string like "-dev" to the version number * for prerelease versions. * @@ -74,7 +71,7 @@ /** The MAJOR version number (increased when backwards API compatibility is broken). */ #define UTF8PROC_VERSION_MAJOR 2 /** The MINOR version number (increased when new functionality is added in a backwards-compatible manner). */ -#define UTF8PROC_VERSION_MINOR 4 +#define UTF8PROC_VERSION_MINOR 9 /** The PATCH version (increased for fixes that do not change the API). */ #define UTF8PROC_VERSION_PATCH 0 /** @} */ @@ -82,7 +79,7 @@ #include #if defined(_MSC_VER) && _MSC_VER < 1800 -// MSVC prior to 2013 lacked stdbool.h and inttypes.h +// MSVC prior to 2013 lacked stdbool.h and stdint.h typedef signed char utf8proc_int8_t; typedef unsigned char utf8proc_uint8_t; typedef short utf8proc_int16_t; @@ -110,29 +107,7 @@ typedef bool utf8proc_bool; #else # include # include -# include -#endif -#include - -#define UTF8PROC_DLLEXPORT -// #ifdef UTF8PROC_STATIC -// # define UTF8PROC_DLLEXPORT -// #else -// # ifdef _WIN32 -// # ifdef UTF8PROC_EXPORTS -// # define UTF8PROC_DLLEXPORT __declspec(dllexport) -// # else -// # define UTF8PROC_DLLEXPORT __declspec(dllimport) -// # endif -// # elif __GNUC__ >= 4 -// # define UTF8PROC_DLLEXPORT __attribute__ ((visibility("default"))) -// # else -// # define UTF8PROC_DLLEXPORT -// # endif -// #endif - -namespace duckdb { - +# include typedef int8_t utf8proc_int8_t; typedef uint8_t utf8proc_uint8_t; typedef int16_t utf8proc_int16_t; @@ -142,10 +117,12 @@ typedef uint32_t utf8proc_uint32_t; typedef size_t utf8proc_size_t; typedef ptrdiff_t utf8proc_ssize_t; typedef bool utf8proc_bool; +#endif +#include -//#ifdef __cplusplus -//extern "C" { -//#endif +# define UTF8PROC_DLLEXPORT + +namespace duckdb { /** * Option flags used by several functions in the library. @@ -268,7 +245,7 @@ typedef struct utf8proc_property_struct { /** * Can this codepoint be ignored? * - * Used by @ref utf8proc_decompose_char when @ref UTF8PROC_IGNORE is + * Used by utf8proc_decompose_char() when @ref UTF8PROC_IGNORE is * passed as an option. */ unsigned ignorable:1; @@ -280,7 +257,8 @@ typedef struct utf8proc_property_struct { * Boundclass. * @see utf8proc_boundclass_t. */ - unsigned boundclass:8; + unsigned boundclass:6; + unsigned indic_conjunct_break:2; } utf8proc_property_t; /** Unicode categories. */ @@ -395,9 +373,17 @@ typedef enum { UTF8PROC_BOUNDCLASS_E_ZWG = 20, /* UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC + ZWJ */ } utf8proc_boundclass_t; +/** Indic_Conjunct_Break property. (TR44) */ +typedef enum { + UTF8PROC_INDIC_CONJUNCT_BREAK_NONE = 0, + UTF8PROC_INDIC_CONJUNCT_BREAK_LINKER = 1, + UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT = 2, + UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND = 3, +} utf8proc_indic_conjunct_break_t; + /** - * Function pointer type passed to @ref utf8proc_map_custom and - * @ref utf8proc_decompose_custom, which is used to specify a user-defined + * Function pointer type passed to utf8proc_map_custom() and + * utf8proc_decompose_custom(), which is used to specify a user-defined * mapping of codepoints to be applied in conjunction with other mappings. */ typedef utf8proc_int32_t (*utf8proc_custom_func)(utf8proc_int32_t codepoint, void *data); @@ -406,7 +392,7 @@ typedef utf8proc_int32_t (*utf8proc_custom_func)(utf8proc_int32_t codepoint, voi * Array containing the byte lengths of a UTF-8 encoded codepoint based * on the first byte. */ -// UTF8PROC_DLLEXPORT extern const utf8proc_int8_t utf8proc_utf8class[256]; +UTF8PROC_DLLEXPORT extern const utf8proc_int8_t utf8proc_utf8class[256]; /** * Returns the utf8proc API version as a string MAJOR.MINOR.PATCH @@ -422,7 +408,7 @@ UTF8PROC_DLLEXPORT const char *utf8proc_unicode_version(void); /** * Returns an informative error string for the given utf8proc error code - * (e.g. the error codes returned by @ref utf8proc_map). + * (e.g. the error codes returned by utf8proc_map()). */ UTF8PROC_DLLEXPORT const char *utf8proc_errmsg(utf8proc_ssize_t errcode); @@ -488,12 +474,13 @@ UTF8PROC_DLLEXPORT const utf8proc_property_t *utf8proc_get_property(utf8proc_int * - @ref UTF8PROC_STRIPNA - remove unassigned codepoints * @param last_boundclass * Pointer to an integer variable containing - * the previous codepoint's boundary class if the @ref UTF8PROC_CHARBOUND - * option is used. Otherwise, this parameter is ignored. + * the previous codepoint's (boundclass + indic_conjunct_break << 1) if the @ref UTF8PROC_CHARBOUND + * option is used. If the string is being processed in order, this can be initialized to 0 for + * the beginning of the string, and is thereafter updated automatically. Otherwise, this parameter is ignored. * * @return * In case of success, the number of codepoints written is returned; in case - * of an error, a negative error code is returned (@ref utf8proc_errmsg). + * of an error, a negative error code is returned (utf8proc_errmsg()). * @par * If the number of written codepoints would be bigger than `bufsize`, the * required buffer size is returned, while the buffer will be overwritten with @@ -505,17 +492,17 @@ UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_decompose_char( ); /** - * The same as @ref utf8proc_decompose_char, but acts on a whole UTF-8 + * The same as utf8proc_decompose_char(), but acts on a whole UTF-8 * string and orders the decomposed sequences correctly. * * If the @ref UTF8PROC_NULLTERM flag in `options` is set, processing - * will be stopped, when a NULL byte is encounted, otherwise `strlen` + * will be stopped, when a NULL byte is encountered, otherwise `strlen` * bytes are processed. The result (in the form of 32-bit unicode * codepoints) is written into the buffer being pointed to by * `buffer` (which must contain at least `bufsize` entries). In case of * success, the number of codepoints written is returned; in case of an - * error, a negative error code is returned (@ref utf8proc_errmsg). - * See @ref utf8proc_decompose_custom to supply additional transformations. + * error, a negative error code is returned (utf8proc_errmsg()). + * See utf8proc_decompose_custom() to supply additional transformations. * * If the number of written codepoints would be bigger than `bufsize`, the * required buffer size is returned, while the buffer will be overwritten with @@ -527,10 +514,10 @@ UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_decompose( ); /** - * The same as @ref utf8proc_decompose, but also takes a `custom_func` mapping function + * The same as utf8proc_decompose(), but also takes a `custom_func` mapping function * that is called on each codepoint in `str` before any other transformations * (along with a `custom_data` pointer that is passed through to `custom_func`). - * The `custom_func` argument is ignored if it is `NULL`. See also @ref utf8proc_map_custom. + * The `custom_func` argument is ignored if it is `NULL`. See also utf8proc_map_custom(). */ UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_decompose_custom( const utf8proc_uint8_t *str, utf8proc_ssize_t strlen, @@ -556,7 +543,7 @@ UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_decompose_custom( * * @return * In case of success, the length (in codepoints) of the normalized UTF-32 string is - * returned; otherwise, a negative error code is returned (@ref utf8proc_errmsg). + * returned; otherwise, a negative error code is returned (utf8proc_errmsg()). * * @warning The entries of the array pointed to by `str` have to be in the * range `0x0000` to `0x10FFFF`. Otherwise, the program might crash! @@ -584,7 +571,7 @@ UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_normalize_utf32(utf8proc_int32_t *b * @return * In case of success, the length (in bytes) of the resulting nul-terminated * UTF-8 string is returned; otherwise, a negative error code is returned - * (@ref utf8proc_errmsg). + * (utf8proc_errmsg()). * * @warning The amount of free space pointed to by `buffer` must * exceed the amount of the input data by one byte, and the @@ -614,43 +601,12 @@ UTF8PROC_DLLEXPORT utf8proc_bool utf8proc_grapheme_break_stateful( utf8proc_int32_t codepoint1, utf8proc_int32_t codepoint2, utf8proc_int32_t *state); /** - * Same as @ref utf8proc_grapheme_break_stateful, except without support for the + * Same as utf8proc_grapheme_break_stateful(), except without support for the * Unicode 9 additions to the algorithm. Supported for legacy reasons. */ UTF8PROC_DLLEXPORT utf8proc_bool utf8proc_grapheme_break( utf8proc_int32_t codepoint1, utf8proc_int32_t codepoint2); -//! Returns the current UTF8 codepoint in a UTF8 string. Assumes the string is valid UTF8. -UTF8PROC_DLLEXPORT utf8proc_int32_t utf8proc_codepoint(const char *u_input, int &sz); -UTF8PROC_DLLEXPORT utf8proc_bool grapheme_break_extended(int lbc, int tbc, utf8proc_int32_t *state); -UTF8PROC_DLLEXPORT utf8proc_int32_t utf8proc_codepoint(const char *u_input, int &sz); -UTF8PROC_DLLEXPORT bool utf8proc_codepoint_to_utf8(int cp, int &sz, char *c); -UTF8PROC_DLLEXPORT int utf8proc_codepoint_length(int cp); -UTF8PROC_DLLEXPORT size_t utf8proc_next_grapheme(const char *s, size_t len, size_t cpos); -UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_remove_accents(const utf8proc_uint8_t *str, utf8proc_ssize_t len); -template -void utf8proc_grapheme_callback(const char *s, size_t len, T &&fun) { - int sz; - int boundclass = UTF8PROC_BOUNDCLASS_START; - int initial = utf8proc_get_property(utf8proc_codepoint(s, sz))->boundclass; - grapheme_break_extended(boundclass, initial, &boundclass); - size_t start = 0; - size_t cpos = 0; - while(true) { - cpos += static_cast(sz); - if (cpos >= len) { - fun(start, cpos); - return; - } - int next = utf8proc_get_property(utf8proc_codepoint(s + cpos, sz))->boundclass; - if (grapheme_break_extended(boundclass, next, &boundclass)) { - if (!fun(start, cpos)) { - return; - } - start = cpos; - } - } -} /** * Given a codepoint `c`, return the codepoint of the corresponding @@ -673,6 +629,18 @@ UTF8PROC_DLLEXPORT utf8proc_int32_t utf8proc_toupper(utf8proc_int32_t c); */ UTF8PROC_DLLEXPORT utf8proc_int32_t utf8proc_totitle(utf8proc_int32_t c); +/** + * Given a codepoint `c`, return `1` if the codepoint corresponds to a lower-case character + * and `0` otherwise. + */ +UTF8PROC_DLLEXPORT int utf8proc_islower(utf8proc_int32_t c); + +/** + * Given a codepoint `c`, return `1` if the codepoint corresponds to an upper-case character + * and `0` otherwise. + */ +UTF8PROC_DLLEXPORT int utf8proc_isupper(utf8proc_int32_t c); + /** * Given a codepoint, return a character width analogous to `wcwidth(codepoint)`, * except that a width of 0 is returned for non-printable codepoints @@ -680,8 +648,8 @@ UTF8PROC_DLLEXPORT utf8proc_int32_t utf8proc_totitle(utf8proc_int32_t c); * * @note * If you want to check for particular types of non-printable characters, - * (analogous to `isprint` or `iscntrl`), use @ref utf8proc_category. */ - UTF8PROC_DLLEXPORT int utf8proc_charwidth(utf8proc_int32_t codepoint); + * (analogous to `isprint` or `iscntrl`), use utf8proc_category(). */ +UTF8PROC_DLLEXPORT int utf8proc_charwidth(utf8proc_int32_t codepoint); /** * Return the Unicode category for the codepoint (one of the @@ -706,7 +674,7 @@ UTF8PROC_DLLEXPORT const char *utf8proc_category_string(utf8proc_int32_t codepoi * contain NULL characters with the string if `str` contained NULL * characters). Other flags in the `options` field are passed to the * functions defined above, and regarded as described. See also - * @ref utf8proc_map_custom to supply a custom codepoint transformation. + * utf8proc_map_custom() to supply a custom codepoint transformation. * * In case of success the length of the new string is returned, * otherwise a negative error code is returned. @@ -719,7 +687,7 @@ UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_map( ); /** - * Like @ref utf8proc_map, but also takes a `custom_func` mapping function + * Like utf8proc_map(), but also takes a `custom_func` mapping function * that is called on each codepoint in `str` before any other transformations * (along with a `custom_data` pointer that is passed through to `custom_func`). * The `custom_func` argument is ignored if it is `NULL`. @@ -733,27 +701,27 @@ UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_map_custom( * * Returns a pointer to newly allocated memory of a NFD, NFC, NFKD, NFKC or * NFKC_Casefold normalized version of the null-terminated string `str`. These - * are shortcuts to calling @ref utf8proc_map with @ref UTF8PROC_NULLTERM + * are shortcuts to calling utf8proc_map() with @ref UTF8PROC_NULLTERM * combined with @ref UTF8PROC_STABLE and flags indicating the normalization. */ /** @{ */ /** NFD normalization (@ref UTF8PROC_DECOMPOSE). */ -UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFD(const utf8proc_uint8_t *str, utf8proc_ssize_t len); +UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFD(const utf8proc_uint8_t *str, utf8proc_ssize_t strlen); /** NFC normalization (@ref UTF8PROC_COMPOSE). */ -UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFC(const utf8proc_uint8_t *str, utf8proc_ssize_t len); +UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFC(const utf8proc_uint8_t *str, utf8proc_ssize_t strlen); +/** remove accents from a string */ +UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_remove_accents(const utf8proc_uint8_t *str, utf8proc_ssize_t strlen); /** NFKD normalization (@ref UTF8PROC_DECOMPOSE and @ref UTF8PROC_COMPAT). */ -UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFKD(const utf8proc_uint8_t *str, utf8proc_ssize_t len); +UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFKD(const utf8proc_uint8_t *str, utf8proc_ssize_t strlen); /** NFKC normalization (@ref UTF8PROC_COMPOSE and @ref UTF8PROC_COMPAT). */ -UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFKC(const utf8proc_uint8_t *str, utf8proc_ssize_t len); +UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFKC(const utf8proc_uint8_t *str, utf8proc_ssize_t strlen); /** * NFKC_Casefold normalization (@ref UTF8PROC_COMPOSE and @ref UTF8PROC_COMPAT * and @ref UTF8PROC_CASEFOLD and @ref UTF8PROC_IGNORE). **/ -UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFKC_Casefold(const utf8proc_uint8_t *str, utf8proc_ssize_t len); +UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFKC_Casefold(const utf8proc_uint8_t *str, utf8proc_ssize_t strlen); /** @} */ -//#ifdef __cplusplus -//} -//#endif } + #endif diff --git a/third_party/utf8proc/include/utf8proc_wrapper.hpp b/third_party/utf8proc/include/utf8proc_wrapper.hpp index a7fb8c662b2..75c9480c2cc 100644 --- a/third_party/utf8proc/include/utf8proc_wrapper.hpp +++ b/third_party/utf8proc/include/utf8proc_wrapper.hpp @@ -14,6 +14,7 @@ #include namespace duckdb { +class GraphemeIterator; enum class UnicodeType { INVALID, ASCII, UNICODE }; enum class UnicodeInvalidReason { BYTE_MISMATCH, INVALID_UNICODE }; @@ -43,6 +44,58 @@ class Utf8Proc { static size_t RenderWidth(const char *s, size_t len, size_t pos); static size_t RenderWidth(const std::string &str); + static int32_t CodepointToUpper(int32_t codepoint); + static int32_t CodepointToLower(int32_t codepoint); + + //! Constructs a class that can be iterated over to fetch grapheme clusters in a string + static GraphemeIterator GraphemeClusters(const char *s, size_t len); + + //! Returns the number of grapheme clusters in a string + static size_t GraphemeCount(const char *s, size_t len); + + }; +struct GraphemeCluster { + size_t start; + size_t end; +}; + +class GraphemeIterator { +public: + GraphemeIterator(const char *s, size_t len); + +private: + const char *s; + size_t len; + +private: + class GraphemeClusterIterator { + public: + GraphemeClusterIterator(const char *s, size_t len); + + const char *s; + size_t len; + GraphemeCluster cluster; + + public: + void Next(); + void SetInvalid(); + bool IsInvalid() const; + + GraphemeClusterIterator &operator++(); + bool operator!=(const GraphemeClusterIterator &other) const; + GraphemeCluster operator*() const; + }; + +public: + GraphemeClusterIterator begin() { // NOLINT: match stl API + return GraphemeClusterIterator(s, len); + } + GraphemeClusterIterator end() { // NOLINT: match stl API + return GraphemeClusterIterator(nullptr, 0); + } +}; + + } diff --git a/third_party/utf8proc/utf8proc.cpp b/third_party/utf8proc/utf8proc.cpp index e4d97aa5be5..bfea42744e4 100644 --- a/third_party/utf8proc/utf8proc.cpp +++ b/third_party/utf8proc/utf8proc.cpp @@ -1,6 +1,6 @@ /* -*- mode: c; c-basic-offset: 2; tab-width: 2; indent-tabs-mode: nil -*- */ /* - * Copyright (c) 2014-2019 Steven G. Johnson, Jiahao Chen, Peter Colberg, Tony Kelman, Scott P. Jones, and other contributors. + * Copyright (c) 2014-2021 Steven G. Johnson, Jiahao Chen, Peter Colberg, Tony Kelman, Scott P. Jones, and other contributors. * Copyright (c) 2009 Public Software Group e. V., Berlin, Germany * * Permission is hereby granted, free of charge, to any person obtaining a @@ -27,7 +27,7 @@ * Unicode data files. * * The original data files are available at - * http://www.unicode.org/Public/UNIDATA/ + * https://www.unicode.org/Public/UNIDATA/ * * Please notice the copyright statement in the file "utf8proc_data.c". */ @@ -44,7 +44,6 @@ #include "utf8proc.hpp" namespace duckdb { - #ifndef SSIZE_MAX #define SSIZE_MAX ((size_t)SIZE_MAX/2) #endif @@ -55,23 +54,23 @@ namespace duckdb { #include "utf8proc_data.cpp" -// UTF8PROC_DLLEXPORT const utf8proc_int8_t utf8proc_utf8class[256] = { -// 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -// 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -// 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -// 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -// 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -// 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -// 1, 1, 1, 1, 1, 1, 1, 1, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -// 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -// 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -// 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, -// 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, -// 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0 }; +UTF8PROC_DLLEXPORT const utf8proc_int8_t utf8proc_utf8class[256] = { + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0 }; #define UTF8PROC_HANGUL_SBASE 0xAC00 #define UTF8PROC_HANGUL_LBASE 0x1100 @@ -94,755 +93,712 @@ namespace duckdb { #define UTF8PROC_HANGUL_S_END 0xD7A4 /* Should follow semantic-versioning rules (semver.org) based on API - compatibility. (Note that the shared-library version number will - be different, being based on ABI compatibility.): */ + compatibility. (Note that the shared-library version number will + be different, being based on ABI compatibility.): */ #define STRINGIZEx(x) #x #define STRINGIZE(x) STRINGIZEx(x) UTF8PROC_DLLEXPORT const char *utf8proc_version(void) { - return STRINGIZE(UTF8PROC_VERSION_MAJOR) "." STRINGIZE(UTF8PROC_VERSION_MINOR) "." STRINGIZE(UTF8PROC_VERSION_PATCH) ""; + return STRINGIZE(UTF8PROC_VERSION_MAJOR) "." STRINGIZE(UTF8PROC_VERSION_MINOR) "." STRINGIZE(UTF8PROC_VERSION_PATCH) ""; } UTF8PROC_DLLEXPORT const char *utf8proc_unicode_version(void) { - return "12.1.0"; + return "15.1.0"; } UTF8PROC_DLLEXPORT const char *utf8proc_errmsg(utf8proc_ssize_t errcode) { - switch (errcode) { - case UTF8PROC_ERROR_NOMEM: - return "Memory for processing UTF-8 data could not be allocated."; - case UTF8PROC_ERROR_OVERFLOW: - return "UTF-8 string is too long to be processed."; - case UTF8PROC_ERROR_INVALIDUTF8: - return "Invalid UTF-8 string"; - case UTF8PROC_ERROR_NOTASSIGNED: - return "Unassigned Unicode code point found in UTF-8 string."; - case UTF8PROC_ERROR_INVALIDOPTS: - return "Invalid options for UTF-8 processing chosen."; - default: - return "An unknown error occurred while processing UTF-8 data."; - } + switch (errcode) { + case UTF8PROC_ERROR_NOMEM: + return "Memory for processing UTF-8 data could not be allocated."; + case UTF8PROC_ERROR_OVERFLOW: + return "UTF-8 string is too long to be processed."; + case UTF8PROC_ERROR_INVALIDUTF8: + return "Invalid UTF-8 string"; + case UTF8PROC_ERROR_NOTASSIGNED: + return "Unassigned Unicode code point found in UTF-8 string."; + case UTF8PROC_ERROR_INVALIDOPTS: + return "Invalid options for UTF-8 processing chosen."; + default: + return "An unknown error occurred while processing UTF-8 data."; + } } #define utf_cont(ch) (((ch) & 0xc0) == 0x80) UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_iterate( - const utf8proc_uint8_t *str, utf8proc_ssize_t strlen, utf8proc_int32_t *dst + const utf8proc_uint8_t *str, utf8proc_ssize_t strlen, utf8proc_int32_t *dst ) { - utf8proc_uint32_t uc; - const utf8proc_uint8_t *end; - - *dst = -1; - if (!strlen) return 0; - end = str + ((strlen < 0) ? 4 : strlen); - uc = *str++; - if (uc < 0x80) { - *dst = uc; - return 1; - } - // Must be between 0xc2 and 0xf4 inclusive to be valid - if ((uc - 0xc2) > (0xf4-0xc2)) return UTF8PROC_ERROR_INVALIDUTF8; - if (uc < 0xe0) { // 2-byte sequence - // Must have valid continuation character - if (str >= end || !utf_cont(*str)) return UTF8PROC_ERROR_INVALIDUTF8; - *dst = ((uc & 0x1f)<<6) | (*str & 0x3f); - return 2; - } - if (uc < 0xf0) { // 3-byte sequence - if ((str + 1 >= end) || !utf_cont(*str) || !utf_cont(str[1])) - return UTF8PROC_ERROR_INVALIDUTF8; - // Check for surrogate chars - if (uc == 0xed && *str > 0x9f) - return UTF8PROC_ERROR_INVALIDUTF8; - uc = ((uc & 0xf)<<12) | ((*str & 0x3f)<<6) | (str[1] & 0x3f); - if (uc < 0x800) - return UTF8PROC_ERROR_INVALIDUTF8; - *dst = uc; - return 3; - } - // 4-byte sequence - // Must have 3 valid continuation characters - if ((str + 2 >= end) || !utf_cont(*str) || !utf_cont(str[1]) || !utf_cont(str[2])) - return UTF8PROC_ERROR_INVALIDUTF8; - // Make sure in correct range (0x10000 - 0x10ffff) - if (uc == 0xf0) { - if (*str < 0x90) return UTF8PROC_ERROR_INVALIDUTF8; - } else if (uc == 0xf4) { - if (*str > 0x8f) return UTF8PROC_ERROR_INVALIDUTF8; - } - *dst = ((uc & 7)<<18) | ((*str & 0x3f)<<12) | ((str[1] & 0x3f)<<6) | (str[2] & 0x3f); - return 4; + utf8proc_int32_t uc; + const utf8proc_uint8_t *end; + + *dst = -1; + if (!strlen) return 0; + end = str + ((strlen < 0) ? 4 : strlen); + uc = *str++; + if (uc < 0x80) { + *dst = uc; + return 1; + } + // Must be between 0xc2 and 0xf4 inclusive to be valid + if ((utf8proc_uint32_t)(uc - 0xc2) > (0xf4-0xc2)) return UTF8PROC_ERROR_INVALIDUTF8; + if (uc < 0xe0) { // 2-byte sequence + // Must have valid continuation character + if (str >= end || !utf_cont(*str)) return UTF8PROC_ERROR_INVALIDUTF8; + *dst = ((uc & 0x1f)<<6) | (*str & 0x3f); + return 2; + } + if (uc < 0xf0) { // 3-byte sequence + if ((str + 1 >= end) || !utf_cont(*str) || !utf_cont(str[1])) + return UTF8PROC_ERROR_INVALIDUTF8; + // Check for surrogate chars + if (uc == 0xed && *str > 0x9f) + return UTF8PROC_ERROR_INVALIDUTF8; + uc = ((uc & 0xf)<<12) | ((*str & 0x3f)<<6) | (str[1] & 0x3f); + if (uc < 0x800) + return UTF8PROC_ERROR_INVALIDUTF8; + *dst = uc; + return 3; + } + // 4-byte sequence + // Must have 3 valid continuation characters + if ((str + 2 >= end) || !utf_cont(*str) || !utf_cont(str[1]) || !utf_cont(str[2])) + return UTF8PROC_ERROR_INVALIDUTF8; + // Make sure in correct range (0x10000 - 0x10ffff) + if (uc == 0xf0) { + if (*str < 0x90) return UTF8PROC_ERROR_INVALIDUTF8; + } else if (uc == 0xf4) { + if (*str > 0x8f) return UTF8PROC_ERROR_INVALIDUTF8; + } + *dst = ((uc & 7)<<18) | ((*str & 0x3f)<<12) | ((str[1] & 0x3f)<<6) | (str[2] & 0x3f); + return 4; } UTF8PROC_DLLEXPORT utf8proc_bool utf8proc_codepoint_valid(utf8proc_int32_t uc) { - return (((utf8proc_uint32_t)uc)-0xd800 > 0x07ff) && ((utf8proc_uint32_t)uc < 0x110000); + return (((utf8proc_uint32_t)uc)-0xd800 > 0x07ff) && ((utf8proc_uint32_t)uc < 0x110000); } UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_encode_char(utf8proc_int32_t uc, utf8proc_uint8_t *dst) { - if (uc < 0x00) { - return 0; - } else if (uc < 0x80) { - dst[0] = (utf8proc_uint8_t) uc; - return 1; - } else if (uc < 0x800) { - dst[0] = (utf8proc_uint8_t)(0xC0 + (uc >> 6)); - dst[1] = (utf8proc_uint8_t)(0x80 + (uc & 0x3F)); - return 2; - // Note: we allow encoding 0xd800-0xdfff here, so as not to change - // the API, however, these are actually invalid in UTF-8 - } else if (uc < 0x10000) { - dst[0] = (utf8proc_uint8_t)(0xE0 + (uc >> 12)); - dst[1] = (utf8proc_uint8_t)(0x80 + ((uc >> 6) & 0x3F)); - dst[2] = (utf8proc_uint8_t)(0x80 + (uc & 0x3F)); - return 3; - } else if (uc < 0x110000) { - dst[0] = (utf8proc_uint8_t)(0xF0 + (uc >> 18)); - dst[1] = (utf8proc_uint8_t)(0x80 + ((uc >> 12) & 0x3F)); - dst[2] = (utf8proc_uint8_t)(0x80 + ((uc >> 6) & 0x3F)); - dst[3] = (utf8proc_uint8_t)(0x80 + (uc & 0x3F)); - return 4; - } else return 0; + if (uc < 0x00) { + return 0; + } else if (uc < 0x80) { + dst[0] = (utf8proc_uint8_t) uc; + return 1; + } else if (uc < 0x800) { + dst[0] = (utf8proc_uint8_t)(0xC0 + (uc >> 6)); + dst[1] = (utf8proc_uint8_t)(0x80 + (uc & 0x3F)); + return 2; + // Note: we allow encoding 0xd800-0xdfff here, so as not to change + // the API, however, these are actually invalid in UTF-8 + } else if (uc < 0x10000) { + dst[0] = (utf8proc_uint8_t)(0xE0 + (uc >> 12)); + dst[1] = (utf8proc_uint8_t)(0x80 + ((uc >> 6) & 0x3F)); + dst[2] = (utf8proc_uint8_t)(0x80 + (uc & 0x3F)); + return 3; + } else if (uc < 0x110000) { + dst[0] = (utf8proc_uint8_t)(0xF0 + (uc >> 18)); + dst[1] = (utf8proc_uint8_t)(0x80 + ((uc >> 12) & 0x3F)); + dst[2] = (utf8proc_uint8_t)(0x80 + ((uc >> 6) & 0x3F)); + dst[3] = (utf8proc_uint8_t)(0x80 + (uc & 0x3F)); + return 4; + } else return 0; } /* internal version used for inserting 0xff bytes between graphemes */ static utf8proc_ssize_t charbound_encode_char(utf8proc_int32_t uc, utf8proc_uint8_t *dst) { - if (uc < 0x00) { - if (uc == -1) { /* internal value used for grapheme breaks */ - dst[0] = (utf8proc_uint8_t)0xFF; - return 1; - } - return 0; - } else if (uc < 0x80) { - dst[0] = (utf8proc_uint8_t)uc; - return 1; - } else if (uc < 0x800) { - dst[0] = (utf8proc_uint8_t)(0xC0 + (uc >> 6)); - dst[1] = (utf8proc_uint8_t)(0x80 + (uc & 0x3F)); - return 2; - } else if (uc < 0x10000) { - dst[0] = (utf8proc_uint8_t)(0xE0 + (uc >> 12)); - dst[1] = (utf8proc_uint8_t)(0x80 + ((uc >> 6) & 0x3F)); - dst[2] = (utf8proc_uint8_t)(0x80 + (uc & 0x3F)); - return 3; - } else if (uc < 0x110000) { - dst[0] = (utf8proc_uint8_t)(0xF0 + (uc >> 18)); - dst[1] = (utf8proc_uint8_t)(0x80 + ((uc >> 12) & 0x3F)); - dst[2] = (utf8proc_uint8_t)(0x80 + ((uc >> 6) & 0x3F)); - dst[3] = (utf8proc_uint8_t)(0x80 + (uc & 0x3F)); - return 4; - } else return 0; + if (uc < 0x00) { + if (uc == -1) { /* internal value used for grapheme breaks */ + dst[0] = (utf8proc_uint8_t)0xFF; + return 1; + } + return 0; + } else if (uc < 0x80) { + dst[0] = (utf8proc_uint8_t)uc; + return 1; + } else if (uc < 0x800) { + dst[0] = (utf8proc_uint8_t)(0xC0 + (uc >> 6)); + dst[1] = (utf8proc_uint8_t)(0x80 + (uc & 0x3F)); + return 2; + } else if (uc < 0x10000) { + dst[0] = (utf8proc_uint8_t)(0xE0 + (uc >> 12)); + dst[1] = (utf8proc_uint8_t)(0x80 + ((uc >> 6) & 0x3F)); + dst[2] = (utf8proc_uint8_t)(0x80 + (uc & 0x3F)); + return 3; + } else if (uc < 0x110000) { + dst[0] = (utf8proc_uint8_t)(0xF0 + (uc >> 18)); + dst[1] = (utf8proc_uint8_t)(0x80 + ((uc >> 12) & 0x3F)); + dst[2] = (utf8proc_uint8_t)(0x80 + ((uc >> 6) & 0x3F)); + dst[3] = (utf8proc_uint8_t)(0x80 + (uc & 0x3F)); + return 4; + } else return 0; } /* internal "unsafe" version that does not check whether uc is in range */ static const utf8proc_property_t *unsafe_get_property(utf8proc_int32_t uc) { - /* ASSERT: uc >= 0 && uc < 0x110000 */ - return utf8proc_properties + ( - utf8proc_stage2table[ - utf8proc_stage1table[uc >> 8] + (uc & 0xFF) - ] - ); + /* ASSERT: uc >= 0 && uc < 0x110000 */ + return utf8proc_properties + ( + utf8proc_stage2table[ + utf8proc_stage1table[uc >> 8] + (uc & 0xFF) + ] + ); } UTF8PROC_DLLEXPORT const utf8proc_property_t *utf8proc_get_property(utf8proc_int32_t uc) { - return uc < 0 || uc >= 0x110000 ? utf8proc_properties : unsafe_get_property(uc); + return uc < 0 || uc >= 0x110000 ? utf8proc_properties : unsafe_get_property(uc); } /* return whether there is a grapheme break between boundclasses lbc and tbc - (according to the definition of extended grapheme clusters) + (according to the definition of extended grapheme clusters) - Rule numbering refers to TR29 Version 29 (Unicode 9.0.0): - http://www.unicode.org/reports/tr29/tr29-29.html + Rule numbering refers to TR29 Version 29 (Unicode 9.0.0): + http://www.unicode.org/reports/tr29/tr29-29.html - CAVEATS: - Please note that evaluation of GB10 (grapheme breaks between emoji zwj sequences) - and GB 12/13 (regional indicator code points) require knowledge of previous characters - and are thus not handled by this function. This may result in an incorrect break before - an E_Modifier class codepoint and an incorrectly missing break between two - REGIONAL_INDICATOR class code points if such support does not exist in the caller. + CAVEATS: + Please note that evaluation of GB10 (grapheme breaks between emoji zwj sequences) + and GB 12/13 (regional indicator code points) require knowledge of previous characters + and are thus not handled by this function. This may result in an incorrect break before + an E_Modifier class codepoint and an incorrectly missing break between two + REGIONAL_INDICATOR class code points if such support does not exist in the caller. - See the special support in grapheme_break_extended, for required bookkeeping by the caller. + See the special support in grapheme_break_extended, for required bookkeeping by the caller. */ static utf8proc_bool grapheme_break_simple(int lbc, int tbc) { - return - (lbc == UTF8PROC_BOUNDCLASS_START) ? true : // GB1 - (lbc == UTF8PROC_BOUNDCLASS_CR && // GB3 - tbc == UTF8PROC_BOUNDCLASS_LF) ? false : // --- - (lbc >= UTF8PROC_BOUNDCLASS_CR && lbc <= UTF8PROC_BOUNDCLASS_CONTROL) ? true : // GB4 - (tbc >= UTF8PROC_BOUNDCLASS_CR && tbc <= UTF8PROC_BOUNDCLASS_CONTROL) ? true : // GB5 - (lbc == UTF8PROC_BOUNDCLASS_L && // GB6 - (tbc == UTF8PROC_BOUNDCLASS_L || // --- - tbc == UTF8PROC_BOUNDCLASS_V || // --- - tbc == UTF8PROC_BOUNDCLASS_LV || // --- - tbc == UTF8PROC_BOUNDCLASS_LVT)) ? false : // --- - ((lbc == UTF8PROC_BOUNDCLASS_LV || // GB7 - lbc == UTF8PROC_BOUNDCLASS_V) && // --- - (tbc == UTF8PROC_BOUNDCLASS_V || // --- - tbc == UTF8PROC_BOUNDCLASS_T)) ? false : // --- - ((lbc == UTF8PROC_BOUNDCLASS_LVT || // GB8 - lbc == UTF8PROC_BOUNDCLASS_T) && // --- - tbc == UTF8PROC_BOUNDCLASS_T) ? false : // --- - (tbc == UTF8PROC_BOUNDCLASS_EXTEND || // GB9 - tbc == UTF8PROC_BOUNDCLASS_ZWJ || // --- - tbc == UTF8PROC_BOUNDCLASS_SPACINGMARK || // GB9a - lbc == UTF8PROC_BOUNDCLASS_PREPEND) ? false : // GB9b - (lbc == UTF8PROC_BOUNDCLASS_E_ZWG && // GB11 (requires additional handling below) - tbc == UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC) ? false : // ---- - (lbc == UTF8PROC_BOUNDCLASS_REGIONAL_INDICATOR && // GB12/13 (requires additional handling below) - tbc == UTF8PROC_BOUNDCLASS_REGIONAL_INDICATOR) ? false : // ---- - true; // GB999 -} - -utf8proc_bool grapheme_break_extended(int lbc, int tbc, utf8proc_int32_t *state) + return + (lbc == UTF8PROC_BOUNDCLASS_START) ? true : // GB1 + (lbc == UTF8PROC_BOUNDCLASS_CR && // GB3 + tbc == UTF8PROC_BOUNDCLASS_LF) ? false : // --- + (lbc >= UTF8PROC_BOUNDCLASS_CR && lbc <= UTF8PROC_BOUNDCLASS_CONTROL) ? true : // GB4 + (tbc >= UTF8PROC_BOUNDCLASS_CR && tbc <= UTF8PROC_BOUNDCLASS_CONTROL) ? true : // GB5 + (lbc == UTF8PROC_BOUNDCLASS_L && // GB6 + (tbc == UTF8PROC_BOUNDCLASS_L || // --- + tbc == UTF8PROC_BOUNDCLASS_V || // --- + tbc == UTF8PROC_BOUNDCLASS_LV || // --- + tbc == UTF8PROC_BOUNDCLASS_LVT)) ? false : // --- + ((lbc == UTF8PROC_BOUNDCLASS_LV || // GB7 + lbc == UTF8PROC_BOUNDCLASS_V) && // --- + (tbc == UTF8PROC_BOUNDCLASS_V || // --- + tbc == UTF8PROC_BOUNDCLASS_T)) ? false : // --- + ((lbc == UTF8PROC_BOUNDCLASS_LVT || // GB8 + lbc == UTF8PROC_BOUNDCLASS_T) && // --- + tbc == UTF8PROC_BOUNDCLASS_T) ? false : // --- + (tbc == UTF8PROC_BOUNDCLASS_EXTEND || // GB9 + tbc == UTF8PROC_BOUNDCLASS_ZWJ || // --- + tbc == UTF8PROC_BOUNDCLASS_SPACINGMARK || // GB9a + lbc == UTF8PROC_BOUNDCLASS_PREPEND) ? false : // GB9b + (lbc == UTF8PROC_BOUNDCLASS_E_ZWG && // GB11 (requires additional handling below) + tbc == UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC) ? false : // ---- + (lbc == UTF8PROC_BOUNDCLASS_REGIONAL_INDICATOR && // GB12/13 (requires additional handling below) + tbc == UTF8PROC_BOUNDCLASS_REGIONAL_INDICATOR) ? false : // ---- + true; // GB999 +} + +static utf8proc_bool grapheme_break_extended(int lbc, int tbc, int licb, int ticb, utf8proc_int32_t *state) { - int lbc_override = ((state && *state != UTF8PROC_BOUNDCLASS_START) - ? *state : lbc); - utf8proc_bool break_permitted = grapheme_break_simple(lbc_override, tbc); - if (state) { - // Special support for GB 12/13 made possible by GB999. After two RI - // class codepoints we want to force a break. Do this by resetting the - // second RI's bound class to UTF8PROC_BOUNDCLASS_OTHER, to force a break - // after that character according to GB999 (unless of course such a break is - // forbidden by a different rule such as GB9). - if (*state == tbc && tbc == UTF8PROC_BOUNDCLASS_REGIONAL_INDICATOR) - *state = UTF8PROC_BOUNDCLASS_OTHER; - // Special support for GB11 (emoji extend* zwj / emoji) - else if (*state == UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC) { - if (tbc == UTF8PROC_BOUNDCLASS_EXTEND) // fold EXTEND codepoints into emoji - *state = UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC; - else if (tbc == UTF8PROC_BOUNDCLASS_ZWJ) - *state = UTF8PROC_BOUNDCLASS_E_ZWG; // state to record emoji+zwg combo - else - *state = tbc; - } - else - *state = tbc; - } - return break_permitted; + if (state) { + int state_bc, state_icb; /* boundclass and indic_conjunct_break state */ + if (*state == 0) { /* state initialization */ + state_bc = lbc; + state_icb = licb == UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT ? licb : UTF8PROC_INDIC_CONJUNCT_BREAK_NONE; + } + else { /* lbc and licb are already encoded in *state */ + state_bc = *state & 0xff; // 1st byte of state is bound class + state_icb = *state >> 8; // 2nd byte of state is indic conjunct break + } + + utf8proc_bool break_permitted = grapheme_break_simple(state_bc, tbc) && + !(state_icb == UTF8PROC_INDIC_CONJUNCT_BREAK_LINKER + && ticb == UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT); // GB9c + + // Special support for GB9c. Don't break between two consonants + // separated 1+ linker characters and 0+ extend characters in any order. + // After a consonant, we enter LINKER state after at least one linker. + if (ticb == UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT + || state_icb == UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT + || state_icb == UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND) + state_icb = ticb; + else if (state_icb == UTF8PROC_INDIC_CONJUNCT_BREAK_LINKER) + state_icb = ticb == UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND ? + UTF8PROC_INDIC_CONJUNCT_BREAK_LINKER : ticb; + + // Special support for GB 12/13 made possible by GB999. After two RI + // class codepoints we want to force a break. Do this by resetting the + // second RI's bound class to UTF8PROC_BOUNDCLASS_OTHER, to force a break + // after that character according to GB999 (unless of course such a break is + // forbidden by a different rule such as GB9). + if (state_bc == tbc && tbc == UTF8PROC_BOUNDCLASS_REGIONAL_INDICATOR) + state_bc = UTF8PROC_BOUNDCLASS_OTHER; + // Special support for GB11 (emoji extend* zwj / emoji) + else if (state_bc == UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC) { + if (tbc == UTF8PROC_BOUNDCLASS_EXTEND) // fold EXTEND codepoints into emoji + state_bc = UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC; + else if (tbc == UTF8PROC_BOUNDCLASS_ZWJ) + state_bc = UTF8PROC_BOUNDCLASS_E_ZWG; // state to record emoji+zwg combo + else + state_bc = tbc; + } + else + state_bc = tbc; + + *state = state_bc + (state_icb << 8); + return break_permitted; + } + else + return grapheme_break_simple(lbc, tbc); } UTF8PROC_DLLEXPORT utf8proc_bool utf8proc_grapheme_break_stateful( - utf8proc_int32_t c1, utf8proc_int32_t c2, utf8proc_int32_t *state) { + utf8proc_int32_t c1, utf8proc_int32_t c2, utf8proc_int32_t *state) { - return grapheme_break_extended(utf8proc_get_property(c1)->boundclass, - utf8proc_get_property(c2)->boundclass, - state); + const utf8proc_property_t *p1 = utf8proc_get_property(c1); + const utf8proc_property_t *p2 = utf8proc_get_property(c2); + return grapheme_break_extended(p1->boundclass, + p2->boundclass, + p1->indic_conjunct_break, + p2->indic_conjunct_break, + state); } UTF8PROC_DLLEXPORT utf8proc_bool utf8proc_grapheme_break( - utf8proc_int32_t c1, utf8proc_int32_t c2) { - return utf8proc_grapheme_break_stateful(c1, c2, NULL); -} - -// from http://www.zedwood.com/article/cpp-utf8-char-to-codepoint -UTF8PROC_DLLEXPORT utf8proc_int32_t utf8proc_codepoint(const char *u_input, int &sz) { - auto u = (const unsigned char *) u_input; - unsigned char u0 = u[0]; - if (u0<=127) { - sz = 1; - return u0; - } - unsigned char u1 = u[1]; - if (u0>=192 && u0<=223) { - sz = 2; - return (u0-192)*64 + (u1-128); - } - if (u[0]==0xed && (u[1] & 0xa0) == 0xa0) { - return -1; //code points, 0xd800 to 0xdfff - } - unsigned char u2 = u[2]; - if (u0>=224 && u0<=239) { - sz = 3; - return (u0-224)*4096 + (u1-128)*64 + (u2-128); - } - unsigned char u3 = u[3]; - if (u0>=240 && u0<=247) { - sz = 4; - return (u0-240)*262144 + (u1-128)*4096 + (u2-128)*64 + (u3-128); - } - return -1; -} - -bool utf8proc_codepoint_to_utf8(int cp, int &sz, char *c) { - if (cp<=0x7F) { - sz = 1; - c[0] = cp; - } else if(cp<=0x7FF) { - sz = 2; - c[0] = (cp>>6)+192; - c[1] = (cp&63)+128; - } else if(0xd800<=cp && cp<=0xdfff) { - sz = -1; - // invalid block of utf - return false; - } else if(cp<=0xFFFF) { - sz = 3; - c[0] = (cp>>12)+224; - c[1]= ((cp>>6)&63)+128; - c[2]=(cp&63)+128; - } else if(cp<=0x10FFFF) { - sz = 4; - c[0] = (cp>>18)+240; - c[1] = ((cp>>12)&63)+128; - c[2] = ((cp>>6)&63)+128; - c[3]=(cp&63)+128; - } else { - sz = -1; - return false; - } - return true; -} - -int utf8proc_codepoint_length(int cp) { - if (cp<=0x7F) { - return 1; - } else if(cp<=0x7FF) { - return 2; - } else if(0xd800<=cp && cp<=0xdfff) { - return -1; - } else if(cp<=0xFFFF) { - return 3; - } else if(cp<=0x10FFFF) { - return 4; - } - return -1; -} - -size_t utf8proc_next_grapheme(const char *s, size_t len, size_t cpos) { - int sz; - int boundclass = UTF8PROC_BOUNDCLASS_START; - int initial = utf8proc_get_property(utf8proc_codepoint(s + cpos, sz))->boundclass; - grapheme_break_extended(boundclass, initial, &boundclass); - while(true) { - cpos += sz; - if (cpos >= len) { - return cpos; - } - int next = utf8proc_get_property(utf8proc_codepoint(s + cpos, sz))->boundclass; - if (grapheme_break_extended(boundclass, next, &boundclass)) { - return cpos; - } - } + utf8proc_int32_t c1, utf8proc_int32_t c2) { + return utf8proc_grapheme_break_stateful(c1, c2, NULL); } static utf8proc_int32_t seqindex_decode_entry(const utf8proc_uint16_t **entry) { - utf8proc_int32_t entry_cp = **entry; - if ((entry_cp & 0xF800) == 0xD800) { - *entry = *entry + 1; - entry_cp = ((entry_cp & 0x03FF) << 10) | (**entry & 0x03FF); - entry_cp += 0x10000; - } - return entry_cp; + utf8proc_int32_t entry_cp = **entry; + if ((entry_cp & 0xF800) == 0xD800) { + *entry = *entry + 1; + entry_cp = ((entry_cp & 0x03FF) << 10) | (**entry & 0x03FF); + entry_cp += 0x10000; + } + return entry_cp; } static utf8proc_int32_t seqindex_decode_index(const utf8proc_uint32_t seqindex) { - const utf8proc_uint16_t *entry = &utf8proc_sequences[seqindex]; - return seqindex_decode_entry(&entry); + const utf8proc_uint16_t *entry = &utf8proc_sequences[seqindex]; + return seqindex_decode_entry(&entry); } static utf8proc_ssize_t seqindex_write_char_decomposed(utf8proc_uint16_t seqindex, utf8proc_int32_t *dst, utf8proc_ssize_t bufsize, utf8proc_option_t options, int *last_boundclass) { - utf8proc_ssize_t written = 0; - const utf8proc_uint16_t *entry = &utf8proc_sequences[seqindex & 0x1FFF]; - int len = seqindex >> 13; - if (len >= 7) { - len = *entry; - entry++; - } - for (; len >= 0; entry++, len--) { - utf8proc_int32_t entry_cp = seqindex_decode_entry(&entry); - utf8proc_int32_t *dst_ptr = dst ? dst + written : nullptr; - written += utf8proc_decompose_char(entry_cp, dst_ptr, - (bufsize > written) ? (bufsize - written) : 0, options, - last_boundclass); - if (written < 0) return UTF8PROC_ERROR_OVERFLOW; - } - return written; + utf8proc_ssize_t written = 0; + const utf8proc_uint16_t *entry = &utf8proc_sequences[seqindex & 0x3FFF]; + int len = seqindex >> 14; + if (len >= 3) { + len = *entry; + entry++; + } + for (; len >= 0; entry++, len--) { + utf8proc_int32_t entry_cp = seqindex_decode_entry(&entry); + + written += utf8proc_decompose_char(entry_cp, dst ? dst+written : nullptr, + (bufsize > written) ? (bufsize - written) : 0, options, + last_boundclass); + if (written < 0) return UTF8PROC_ERROR_OVERFLOW; + } + return written; } UTF8PROC_DLLEXPORT utf8proc_int32_t utf8proc_tolower(utf8proc_int32_t c) { - utf8proc_int32_t cl = utf8proc_get_property(c)->lowercase_seqindex; - return cl != UINT16_MAX ? seqindex_decode_index(cl) : c; + utf8proc_int32_t cl = utf8proc_get_property(c)->lowercase_seqindex; + return cl != UINT16_MAX ? seqindex_decode_index((utf8proc_uint32_t)cl) : c; } UTF8PROC_DLLEXPORT utf8proc_int32_t utf8proc_toupper(utf8proc_int32_t c) { - utf8proc_int32_t cu = utf8proc_get_property(c)->uppercase_seqindex; - return cu != UINT16_MAX ? seqindex_decode_index(cu) : c; + utf8proc_int32_t cu = utf8proc_get_property(c)->uppercase_seqindex; + return cu != UINT16_MAX ? seqindex_decode_index((utf8proc_uint32_t)cu) : c; } UTF8PROC_DLLEXPORT utf8proc_int32_t utf8proc_totitle(utf8proc_int32_t c) { - utf8proc_int32_t cu = utf8proc_get_property(c)->titlecase_seqindex; - return cu != UINT16_MAX ? seqindex_decode_index(cu) : c; + utf8proc_int32_t cu = utf8proc_get_property(c)->titlecase_seqindex; + return cu != UINT16_MAX ? seqindex_decode_index((utf8proc_uint32_t)cu) : c; +} + +UTF8PROC_DLLEXPORT int utf8proc_islower(utf8proc_int32_t c) +{ + const utf8proc_property_t *p = utf8proc_get_property(c); + return p->lowercase_seqindex != p->uppercase_seqindex && p->lowercase_seqindex == UINT16_MAX; +} + +UTF8PROC_DLLEXPORT int utf8proc_isupper(utf8proc_int32_t c) +{ + const utf8proc_property_t *p = utf8proc_get_property(c); + return p->lowercase_seqindex != p->uppercase_seqindex && p->uppercase_seqindex == UINT16_MAX && p->category != UTF8PROC_CATEGORY_LT; } /* return a character width analogous to wcwidth (except portable and - hopefully less buggy than most system wcwidth functions). */ + hopefully less buggy than most system wcwidth functions). */ UTF8PROC_DLLEXPORT int utf8proc_charwidth(utf8proc_int32_t c) { - return utf8proc_get_property(c)->charwidth; + return utf8proc_get_property(c)->charwidth; } UTF8PROC_DLLEXPORT utf8proc_category_t utf8proc_category(utf8proc_int32_t c) { - return (utf8proc_category_t)utf8proc_get_property(c)->category; + return (utf8proc_category_t) utf8proc_get_property(c)->category; } UTF8PROC_DLLEXPORT const char *utf8proc_category_string(utf8proc_int32_t c) { - static const char s[][3] = {"Cn","Lu","Ll","Lt","Lm","Lo","Mn","Mc","Me","Nd","Nl","No","Pc","Pd","Ps","Pe","Pi","Pf","Po","Sm","Sc","Sk","So","Zs","Zl","Zp","Cc","Cf","Cs","Co"}; - return s[utf8proc_category(c)]; + static const char s[][3] = {"Cn","Lu","Ll","Lt","Lm","Lo","Mn","Mc","Me","Nd","Nl","No","Pc","Pd","Ps","Pe","Pi","Pf","Po","Sm","Sc","Sk","So","Zs","Zl","Zp","Cc","Cf","Cs","Co"}; + return s[utf8proc_category(c)]; } #define utf8proc_decompose_lump(replacement_uc) \ - return utf8proc_decompose_char((replacement_uc), dst, bufsize, \ - (utf8proc_option_t) (options & ~UTF8PROC_LUMP), last_boundclass) +return utf8proc_decompose_char((replacement_uc), dst, bufsize, \ +(utf8proc_option_t)(options & ~(unsigned int)UTF8PROC_LUMP), last_boundclass) UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_decompose_char(utf8proc_int32_t uc, utf8proc_int32_t *dst, utf8proc_ssize_t bufsize, utf8proc_option_t options, int *last_boundclass) { - const utf8proc_property_t *property; - utf8proc_propval_t category; - utf8proc_int32_t hangul_sindex; - if (uc < 0 || uc >= 0x110000) return UTF8PROC_ERROR_NOTASSIGNED; - property = unsafe_get_property(uc); - category = property->category; - hangul_sindex = uc - UTF8PROC_HANGUL_SBASE; - if (options & (UTF8PROC_COMPOSE|UTF8PROC_DECOMPOSE)) { - if (hangul_sindex >= 0 && hangul_sindex < UTF8PROC_HANGUL_SCOUNT) { - utf8proc_int32_t hangul_tindex; - if (bufsize >= 1) { - dst[0] = UTF8PROC_HANGUL_LBASE + - hangul_sindex / UTF8PROC_HANGUL_NCOUNT; - if (bufsize >= 2) dst[1] = UTF8PROC_HANGUL_VBASE + - (hangul_sindex % UTF8PROC_HANGUL_NCOUNT) / UTF8PROC_HANGUL_TCOUNT; - } - hangul_tindex = hangul_sindex % UTF8PROC_HANGUL_TCOUNT; - if (!hangul_tindex) return 2; - if (bufsize >= 3) dst[2] = UTF8PROC_HANGUL_TBASE + hangul_tindex; - return 3; - } - } - if (options & UTF8PROC_REJECTNA) { - if (!category) return UTF8PROC_ERROR_NOTASSIGNED; - } - if (options & UTF8PROC_IGNORE) { - if (property->ignorable) return 0; - } - if (options & UTF8PROC_STRIPNA) { - if (!category) return 0; - } - if (options & UTF8PROC_LUMP) { - if (category == UTF8PROC_CATEGORY_ZS) utf8proc_decompose_lump(0x0020); - if (uc == 0x2018 || uc == 0x2019 || uc == 0x02BC || uc == 0x02C8) - utf8proc_decompose_lump(0x0027); - if (category == UTF8PROC_CATEGORY_PD || uc == 0x2212) - utf8proc_decompose_lump(0x002D); - if (uc == 0x2044 || uc == 0x2215) utf8proc_decompose_lump(0x002F); - if (uc == 0x2236) utf8proc_decompose_lump(0x003A); - if (uc == 0x2039 || uc == 0x2329 || uc == 0x3008) - utf8proc_decompose_lump(0x003C); - if (uc == 0x203A || uc == 0x232A || uc == 0x3009) - utf8proc_decompose_lump(0x003E); - if (uc == 0x2216) utf8proc_decompose_lump(0x005C); - if (uc == 0x02C4 || uc == 0x02C6 || uc == 0x2038 || uc == 0x2303) - utf8proc_decompose_lump(0x005E); - if (category == UTF8PROC_CATEGORY_PC || uc == 0x02CD) - utf8proc_decompose_lump(0x005F); - if (uc == 0x02CB) utf8proc_decompose_lump(0x0060); - if (uc == 0x2223) utf8proc_decompose_lump(0x007C); - if (uc == 0x223C) utf8proc_decompose_lump(0x007E); - if ((options & UTF8PROC_NLF2LS) && (options & UTF8PROC_NLF2PS)) { - if (category == UTF8PROC_CATEGORY_ZL || - category == UTF8PROC_CATEGORY_ZP) - utf8proc_decompose_lump(0x000A); - } - } - if (options & UTF8PROC_STRIPMARK) { - if (category == UTF8PROC_CATEGORY_MN || - category == UTF8PROC_CATEGORY_MC || - category == UTF8PROC_CATEGORY_ME) return 0; - } - if (options & UTF8PROC_CASEFOLD) { - if (property->casefold_seqindex != UINT16_MAX) { - return seqindex_write_char_decomposed(property->casefold_seqindex, dst, bufsize, options, last_boundclass); - } - } - if (options & (UTF8PROC_COMPOSE|UTF8PROC_DECOMPOSE)) { - if (property->decomp_seqindex != UINT16_MAX && - (!property->decomp_type || (options & UTF8PROC_COMPAT))) { - return seqindex_write_char_decomposed(property->decomp_seqindex, dst, bufsize, options, last_boundclass); - } - } - if (options & UTF8PROC_CHARBOUND) { - utf8proc_bool boundary; - int tbc = property->boundclass; - boundary = grapheme_break_extended(*last_boundclass, tbc, last_boundclass); - if (boundary) { - if (bufsize >= 1) dst[0] = -1; /* sentinel value for grapheme break */ - if (bufsize >= 2) dst[1] = uc; - return 2; - } - } - if (bufsize >= 1) *dst = uc; - return 1; + const utf8proc_property_t *property; + utf8proc_propval_t category; + utf8proc_int32_t hangul_sindex; + if (uc < 0 || uc >= 0x110000) return UTF8PROC_ERROR_NOTASSIGNED; + property = unsafe_get_property(uc); + category = property->category; + hangul_sindex = uc - UTF8PROC_HANGUL_SBASE; + if (options & (UTF8PROC_COMPOSE|UTF8PROC_DECOMPOSE)) { + if (hangul_sindex >= 0 && hangul_sindex < UTF8PROC_HANGUL_SCOUNT) { + utf8proc_int32_t hangul_tindex; + if (bufsize >= 1) { + dst[0] = UTF8PROC_HANGUL_LBASE + + hangul_sindex / UTF8PROC_HANGUL_NCOUNT; + if (bufsize >= 2) dst[1] = UTF8PROC_HANGUL_VBASE + + (hangul_sindex % UTF8PROC_HANGUL_NCOUNT) / UTF8PROC_HANGUL_TCOUNT; + } + hangul_tindex = hangul_sindex % UTF8PROC_HANGUL_TCOUNT; + if (!hangul_tindex) return 2; + if (bufsize >= 3) dst[2] = UTF8PROC_HANGUL_TBASE + hangul_tindex; + return 3; + } + } + if (options & UTF8PROC_REJECTNA) { + if (!category) return UTF8PROC_ERROR_NOTASSIGNED; + } + if (options & UTF8PROC_IGNORE) { + if (property->ignorable) return 0; + } + if (options & UTF8PROC_STRIPNA) { + if (!category) return 0; + } + if (options & UTF8PROC_LUMP) { + if (category == UTF8PROC_CATEGORY_ZS) utf8proc_decompose_lump(0x0020); + if (uc == 0x2018 || uc == 0x2019 || uc == 0x02BC || uc == 0x02C8) + utf8proc_decompose_lump(0x0027); + if (category == UTF8PROC_CATEGORY_PD || uc == 0x2212) + utf8proc_decompose_lump(0x002D); + if (uc == 0x2044 || uc == 0x2215) utf8proc_decompose_lump(0x002F); + if (uc == 0x2236) utf8proc_decompose_lump(0x003A); + if (uc == 0x2039 || uc == 0x2329 || uc == 0x3008) + utf8proc_decompose_lump(0x003C); + if (uc == 0x203A || uc == 0x232A || uc == 0x3009) + utf8proc_decompose_lump(0x003E); + if (uc == 0x2216) utf8proc_decompose_lump(0x005C); + if (uc == 0x02C4 || uc == 0x02C6 || uc == 0x2038 || uc == 0x2303) + utf8proc_decompose_lump(0x005E); + if (category == UTF8PROC_CATEGORY_PC || uc == 0x02CD) + utf8proc_decompose_lump(0x005F); + if (uc == 0x02CB) utf8proc_decompose_lump(0x0060); + if (uc == 0x2223) utf8proc_decompose_lump(0x007C); + if (uc == 0x223C) utf8proc_decompose_lump(0x007E); + if ((options & UTF8PROC_NLF2LS) && (options & UTF8PROC_NLF2PS)) { + if (category == UTF8PROC_CATEGORY_ZL || + category == UTF8PROC_CATEGORY_ZP) + utf8proc_decompose_lump(0x000A); + } + } + if (options & UTF8PROC_STRIPMARK) { + if (category == UTF8PROC_CATEGORY_MN || + category == UTF8PROC_CATEGORY_MC || + category == UTF8PROC_CATEGORY_ME) return 0; + } + if (options & UTF8PROC_CASEFOLD) { + if (property->casefold_seqindex != UINT16_MAX) { + return seqindex_write_char_decomposed(property->casefold_seqindex, dst, bufsize, options, last_boundclass); + } + } + if (options & (UTF8PROC_COMPOSE|UTF8PROC_DECOMPOSE)) { + if (property->decomp_seqindex != UINT16_MAX && + (!property->decomp_type || (options & UTF8PROC_COMPAT))) { + return seqindex_write_char_decomposed(property->decomp_seqindex, dst, bufsize, options, last_boundclass); + } + } + if (options & UTF8PROC_CHARBOUND) { + utf8proc_bool boundary; + boundary = grapheme_break_extended(0, property->boundclass, 0, property->indic_conjunct_break, + last_boundclass); + if (boundary) { + if (bufsize >= 1) dst[0] = -1; /* sentinel value for grapheme break */ + if (bufsize >= 2) dst[1] = uc; + return 2; + } + } + if (bufsize >= 1) *dst = uc; + return 1; } UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_decompose( - const utf8proc_uint8_t *str, utf8proc_ssize_t strlen, - utf8proc_int32_t *buffer, utf8proc_ssize_t bufsize, utf8proc_option_t options + const utf8proc_uint8_t *str, utf8proc_ssize_t strlen, + utf8proc_int32_t *buffer, utf8proc_ssize_t bufsize, utf8proc_option_t options ) { - return utf8proc_decompose_custom(str, strlen, buffer, bufsize, options, NULL, NULL); + return utf8proc_decompose_custom(str, strlen, buffer, bufsize, options, NULL, NULL); } UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_decompose_custom( - const utf8proc_uint8_t *str, utf8proc_ssize_t strlen, - utf8proc_int32_t *buffer, utf8proc_ssize_t bufsize, utf8proc_option_t options, - utf8proc_custom_func custom_func, void *custom_data + const utf8proc_uint8_t *str, utf8proc_ssize_t strlen, + utf8proc_int32_t *buffer, utf8proc_ssize_t bufsize, utf8proc_option_t options, + utf8proc_custom_func custom_func, void *custom_data ) { - /* strlen will be ignored, if UTF8PROC_NULLTERM is set in options */ - utf8proc_ssize_t wpos = 0; - if ((options & UTF8PROC_COMPOSE) && (options & UTF8PROC_DECOMPOSE)) - return UTF8PROC_ERROR_INVALIDOPTS; - if ((options & UTF8PROC_STRIPMARK) && - !(options & UTF8PROC_COMPOSE) && !(options & UTF8PROC_DECOMPOSE)) - return UTF8PROC_ERROR_INVALIDOPTS; - { - utf8proc_int32_t uc; - utf8proc_ssize_t rpos = 0; - utf8proc_ssize_t decomp_result; - int boundclass = UTF8PROC_BOUNDCLASS_START; - while (1) { - if (options & UTF8PROC_NULLTERM) { - rpos += utf8proc_iterate(str + rpos, -1, &uc); - /* checking of return value is not necessary, - as 'uc' is < 0 in case of error */ - if (uc < 0) return UTF8PROC_ERROR_INVALIDUTF8; - if (rpos < 0) return UTF8PROC_ERROR_OVERFLOW; - if (uc == 0) break; - } else { - if (rpos >= strlen) break; - rpos += utf8proc_iterate(str + rpos, strlen - rpos, &uc); - if (uc < 0) return UTF8PROC_ERROR_INVALIDUTF8; - } - if (custom_func != NULL) { - uc = custom_func(uc, custom_data); /* user-specified custom mapping */ - } - utf8proc_int32_t *target_buffer = buffer ? buffer + wpos : nullptr; - decomp_result = utf8proc_decompose_char( - uc, target_buffer, (bufsize > wpos) ? (bufsize - wpos) : 0, options, - &boundclass - ); - if (decomp_result < 0) return decomp_result; - wpos += decomp_result; - /* prohibiting integer overflows due to too long strings: */ - if (wpos < 0 || - wpos > (utf8proc_ssize_t)(SSIZE_MAX/sizeof(utf8proc_int32_t)/2)) - return UTF8PROC_ERROR_OVERFLOW; - } - } - if ((options & (UTF8PROC_COMPOSE|UTF8PROC_DECOMPOSE)) && bufsize >= wpos) { - utf8proc_ssize_t pos = 0; - while (pos < wpos-1) { - utf8proc_int32_t uc1, uc2; - const utf8proc_property_t *property1, *property2; - uc1 = buffer[pos]; - uc2 = buffer[pos+1]; - property1 = unsafe_get_property(uc1); - property2 = unsafe_get_property(uc2); - if (property1->combining_class > property2->combining_class && - property2->combining_class > 0) { - buffer[pos] = uc2; - buffer[pos+1] = uc1; - if (pos > 0) pos--; else pos++; - } else { - pos++; - } - } - } - return wpos; + /* strlen will be ignored, if UTF8PROC_NULLTERM is set in options */ + utf8proc_ssize_t wpos = 0; + if ((options & UTF8PROC_COMPOSE) && (options & UTF8PROC_DECOMPOSE)) + return UTF8PROC_ERROR_INVALIDOPTS; + if ((options & UTF8PROC_STRIPMARK) && + !(options & UTF8PROC_COMPOSE) && !(options & UTF8PROC_DECOMPOSE)) + return UTF8PROC_ERROR_INVALIDOPTS; + { + utf8proc_int32_t uc; + utf8proc_ssize_t rpos = 0; + utf8proc_ssize_t decomp_result; + int boundclass = UTF8PROC_BOUNDCLASS_START; + while (1) { + if (options & UTF8PROC_NULLTERM) { + rpos += utf8proc_iterate(str + rpos, -1, &uc); + /* checking of return value is not necessary, + as 'uc' is < 0 in case of error */ + if (uc < 0) return UTF8PROC_ERROR_INVALIDUTF8; + if (rpos < 0) return UTF8PROC_ERROR_OVERFLOW; + if (uc == 0) break; + } else { + if (rpos >= strlen) break; + rpos += utf8proc_iterate(str + rpos, strlen - rpos, &uc); + if (uc < 0) return UTF8PROC_ERROR_INVALIDUTF8; + } + if (custom_func != NULL) { + uc = custom_func(uc, custom_data); /* user-specified custom mapping */ + } + decomp_result = utf8proc_decompose_char( + uc, buffer ? buffer + wpos : nullptr, (bufsize > wpos) ? (bufsize - wpos) : 0, options, + &boundclass + ); + if (decomp_result < 0) return decomp_result; + wpos += decomp_result; + /* prohibiting integer overflows due to too long strings: */ + if (wpos < 0 || + wpos > (utf8proc_ssize_t)(SSIZE_MAX/sizeof(utf8proc_int32_t)/2)) + return UTF8PROC_ERROR_OVERFLOW; + } + } + if ((options & (UTF8PROC_COMPOSE|UTF8PROC_DECOMPOSE)) && bufsize >= wpos) { + utf8proc_ssize_t pos = 0; + while (pos < wpos-1) { + utf8proc_int32_t uc1, uc2; + const utf8proc_property_t *property1, *property2; + uc1 = buffer[pos]; + uc2 = buffer[pos+1]; + property1 = unsafe_get_property(uc1); + property2 = unsafe_get_property(uc2); + if (property1->combining_class > property2->combining_class && + property2->combining_class > 0) { + buffer[pos] = uc2; + buffer[pos+1] = uc1; + if (pos > 0) pos--; else pos++; + } else { + pos++; + } + } + } + return wpos; } UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_normalize_utf32(utf8proc_int32_t *buffer, utf8proc_ssize_t length, utf8proc_option_t options) { - /* UTF8PROC_NULLTERM option will be ignored, 'length' is never ignored */ - if (options & (UTF8PROC_NLF2LS | UTF8PROC_NLF2PS | UTF8PROC_STRIPCC)) { - utf8proc_ssize_t rpos; - utf8proc_ssize_t wpos = 0; - utf8proc_int32_t uc; - for (rpos = 0; rpos < length; rpos++) { - uc = buffer[rpos]; - if (uc == 0x000D && rpos < length-1 && buffer[rpos+1] == 0x000A) rpos++; - if (uc == 0x000A || uc == 0x000D || uc == 0x0085 || - ((options & UTF8PROC_STRIPCC) && (uc == 0x000B || uc == 0x000C))) { - if (options & UTF8PROC_NLF2LS) { - if (options & UTF8PROC_NLF2PS) { - buffer[wpos++] = 0x000A; - } else { - buffer[wpos++] = 0x2028; - } - } else { - if (options & UTF8PROC_NLF2PS) { - buffer[wpos++] = 0x2029; - } else { - buffer[wpos++] = 0x0020; - } - } - } else if ((options & UTF8PROC_STRIPCC) && - (uc < 0x0020 || (uc >= 0x007F && uc < 0x00A0))) { - if (uc == 0x0009) buffer[wpos++] = 0x0020; - } else { - buffer[wpos++] = uc; - } - } - length = wpos; - } - if (options & UTF8PROC_COMPOSE) { - utf8proc_int32_t *starter = NULL; - utf8proc_int32_t current_char; - const utf8proc_property_t *starter_property = NULL, *current_property; - utf8proc_propval_t max_combining_class = -1; - utf8proc_ssize_t rpos; - utf8proc_ssize_t wpos = 0; - utf8proc_int32_t composition; - for (rpos = 0; rpos < length; rpos++) { - current_char = buffer[rpos]; - current_property = unsafe_get_property(current_char); - if (starter && current_property->combining_class > max_combining_class) { - /* combination perhaps possible */ - utf8proc_int32_t hangul_lindex; - utf8proc_int32_t hangul_sindex; - hangul_lindex = *starter - UTF8PROC_HANGUL_LBASE; - if (hangul_lindex >= 0 && hangul_lindex < UTF8PROC_HANGUL_LCOUNT) { - utf8proc_int32_t hangul_vindex; - hangul_vindex = current_char - UTF8PROC_HANGUL_VBASE; - if (hangul_vindex >= 0 && hangul_vindex < UTF8PROC_HANGUL_VCOUNT) { - *starter = UTF8PROC_HANGUL_SBASE + - (hangul_lindex * UTF8PROC_HANGUL_VCOUNT + hangul_vindex) * - UTF8PROC_HANGUL_TCOUNT; - starter_property = NULL; - continue; - } - } - hangul_sindex = *starter - UTF8PROC_HANGUL_SBASE; - if (hangul_sindex >= 0 && hangul_sindex < UTF8PROC_HANGUL_SCOUNT && - (hangul_sindex % UTF8PROC_HANGUL_TCOUNT) == 0) { - utf8proc_int32_t hangul_tindex; - hangul_tindex = current_char - UTF8PROC_HANGUL_TBASE; - if (hangul_tindex >= 0 && hangul_tindex < UTF8PROC_HANGUL_TCOUNT) { - *starter += hangul_tindex; - starter_property = NULL; - continue; - } - } - if (!starter_property) { - starter_property = unsafe_get_property(*starter); - } - if (starter_property->comb_index < 0x8000 && - current_property->comb_index != UINT16_MAX && - current_property->comb_index >= 0x8000) { - int sidx = starter_property->comb_index; - int idx = current_property->comb_index & 0x3FFF; - if (idx >= utf8proc_combinations[sidx] && idx <= utf8proc_combinations[sidx + 1] ) { - idx += sidx + 2 - utf8proc_combinations[sidx]; - if (current_property->comb_index & 0x4000) { - composition = (utf8proc_combinations[idx] << 16) | utf8proc_combinations[idx+1]; - } else - composition = utf8proc_combinations[idx]; - - if (composition > 0 && (!(options & UTF8PROC_STABLE) || - !(unsafe_get_property(composition)->comp_exclusion))) { - *starter = composition; - starter_property = NULL; - continue; - } - } - } - } - buffer[wpos] = current_char; - if (current_property->combining_class) { - if (current_property->combining_class > max_combining_class) { - max_combining_class = current_property->combining_class; - } - } else { - starter = buffer + wpos; - starter_property = NULL; - max_combining_class = -1; - } - wpos++; - } - length = wpos; - } - return length; + /* UTF8PROC_NULLTERM option will be ignored, 'length' is never ignored */ + if (options & (UTF8PROC_NLF2LS | UTF8PROC_NLF2PS | UTF8PROC_STRIPCC)) { + utf8proc_ssize_t rpos; + utf8proc_ssize_t wpos = 0; + utf8proc_int32_t uc; + for (rpos = 0; rpos < length; rpos++) { + uc = buffer[rpos]; + if (uc == 0x000D && rpos < length-1 && buffer[rpos+1] == 0x000A) rpos++; + if (uc == 0x000A || uc == 0x000D || uc == 0x0085 || + ((options & UTF8PROC_STRIPCC) && (uc == 0x000B || uc == 0x000C))) { + if (options & UTF8PROC_NLF2LS) { + if (options & UTF8PROC_NLF2PS) { + buffer[wpos++] = 0x000A; + } else { + buffer[wpos++] = 0x2028; + } + } else { + if (options & UTF8PROC_NLF2PS) { + buffer[wpos++] = 0x2029; + } else { + buffer[wpos++] = 0x0020; + } + } + } else if ((options & UTF8PROC_STRIPCC) && + (uc < 0x0020 || (uc >= 0x007F && uc < 0x00A0))) { + if (uc == 0x0009) buffer[wpos++] = 0x0020; + } else { + buffer[wpos++] = uc; + } + } + length = wpos; + } + if (options & UTF8PROC_COMPOSE) { + utf8proc_int32_t *starter = NULL; + utf8proc_int32_t current_char; + const utf8proc_property_t *starter_property = NULL, *current_property; + utf8proc_propval_t max_combining_class = -1; + utf8proc_ssize_t rpos; + utf8proc_ssize_t wpos = 0; + utf8proc_int32_t composition; + for (rpos = 0; rpos < length; rpos++) { + current_char = buffer[rpos]; + current_property = unsafe_get_property(current_char); + if (starter && current_property->combining_class > max_combining_class) { + /* combination perhaps possible */ + utf8proc_int32_t hangul_lindex; + utf8proc_int32_t hangul_sindex; + hangul_lindex = *starter - UTF8PROC_HANGUL_LBASE; + if (hangul_lindex >= 0 && hangul_lindex < UTF8PROC_HANGUL_LCOUNT) { + utf8proc_int32_t hangul_vindex; + hangul_vindex = current_char - UTF8PROC_HANGUL_VBASE; + if (hangul_vindex >= 0 && hangul_vindex < UTF8PROC_HANGUL_VCOUNT) { + *starter = UTF8PROC_HANGUL_SBASE + + (hangul_lindex * UTF8PROC_HANGUL_VCOUNT + hangul_vindex) * + UTF8PROC_HANGUL_TCOUNT; + starter_property = NULL; + continue; + } + } + hangul_sindex = *starter - UTF8PROC_HANGUL_SBASE; + if (hangul_sindex >= 0 && hangul_sindex < UTF8PROC_HANGUL_SCOUNT && + (hangul_sindex % UTF8PROC_HANGUL_TCOUNT) == 0) { + utf8proc_int32_t hangul_tindex; + hangul_tindex = current_char - UTF8PROC_HANGUL_TBASE; + if (hangul_tindex >= 0 && hangul_tindex < UTF8PROC_HANGUL_TCOUNT) { + *starter += hangul_tindex; + starter_property = NULL; + continue; + } + } + if (!starter_property) { + starter_property = unsafe_get_property(*starter); + } + if (starter_property->comb_index < 0x8000 && + current_property->comb_index != UINT16_MAX && + current_property->comb_index >= 0x8000) { + int sidx = starter_property->comb_index; + int idx = current_property->comb_index & 0x3FFF; + if (idx >= utf8proc_combinations[sidx] && idx <= utf8proc_combinations[sidx + 1] ) { + idx += sidx + 2 - utf8proc_combinations[sidx]; + if (current_property->comb_index & 0x4000) { + composition = (utf8proc_combinations[idx] << 16) | utf8proc_combinations[idx+1]; + } else + composition = utf8proc_combinations[idx]; + + if (composition > 0 && (!(options & UTF8PROC_STABLE) || + !(unsafe_get_property(composition)->comp_exclusion))) { + *starter = composition; + starter_property = NULL; + continue; + } + } + } + } + buffer[wpos] = current_char; + if (current_property->combining_class) { + if (current_property->combining_class > max_combining_class) { + max_combining_class = current_property->combining_class; + } + } else { + starter = buffer + wpos; + starter_property = NULL; + max_combining_class = -1; + } + wpos++; + } + length = wpos; + } + return length; } UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_reencode(utf8proc_int32_t *buffer, utf8proc_ssize_t length, utf8proc_option_t options) { - /* UTF8PROC_NULLTERM option will be ignored, 'length' is never ignored - ASSERT: 'buffer' has one spare byte of free space at the end! */ - length = utf8proc_normalize_utf32(buffer, length, options); - if (length < 0) return length; - { - utf8proc_ssize_t rpos, wpos = 0; - utf8proc_int32_t uc; - if (options & UTF8PROC_CHARBOUND) { - for (rpos = 0; rpos < length; rpos++) { - uc = buffer[rpos]; - wpos += charbound_encode_char(uc, ((utf8proc_uint8_t *)buffer) + wpos); - } - } else { - for (rpos = 0; rpos < length; rpos++) { - uc = buffer[rpos]; - wpos += utf8proc_encode_char(uc, ((utf8proc_uint8_t *)buffer) + wpos); - } - } - ((utf8proc_uint8_t *)buffer)[wpos] = 0; - return wpos; - } + /* UTF8PROC_NULLTERM option will be ignored, 'length' is never ignored + ASSERT: 'buffer' has one spare byte of free space at the end! */ + length = utf8proc_normalize_utf32(buffer, length, options); + if (length < 0) return length; + { + utf8proc_ssize_t rpos, wpos = 0; + utf8proc_int32_t uc; + if (options & UTF8PROC_CHARBOUND) { + for (rpos = 0; rpos < length; rpos++) { + uc = buffer[rpos]; + wpos += charbound_encode_char(uc, ((utf8proc_uint8_t *)buffer) + wpos); + } + } else { + for (rpos = 0; rpos < length; rpos++) { + uc = buffer[rpos]; + wpos += utf8proc_encode_char(uc, ((utf8proc_uint8_t *)buffer) + wpos); + } + } + ((utf8proc_uint8_t *)buffer)[wpos] = 0; + return wpos; + } } UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_map( - const utf8proc_uint8_t *str, utf8proc_ssize_t strlen, utf8proc_uint8_t **dstptr, utf8proc_option_t options + const utf8proc_uint8_t *str, utf8proc_ssize_t strlen, utf8proc_uint8_t **dstptr, utf8proc_option_t options ) { - return utf8proc_map_custom(str, strlen, dstptr, options, NULL, NULL); + return utf8proc_map_custom(str, strlen, dstptr, options, NULL, NULL); } UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_map_custom( - const utf8proc_uint8_t *str, utf8proc_ssize_t strlen, utf8proc_uint8_t **dstptr, utf8proc_option_t options, - utf8proc_custom_func custom_func, void *custom_data + const utf8proc_uint8_t *str, utf8proc_ssize_t strlen, utf8proc_uint8_t **dstptr, utf8proc_option_t options, + utf8proc_custom_func custom_func, void *custom_data ) { - utf8proc_int32_t *buffer; - utf8proc_ssize_t result; - *dstptr = NULL; - result = utf8proc_decompose_custom(str, strlen, NULL, 0, options, custom_func, custom_data); - if (result < 0) return result; - buffer = (utf8proc_int32_t *) malloc(result * sizeof(utf8proc_int32_t) + 1); - if (!buffer) return UTF8PROC_ERROR_NOMEM; - result = utf8proc_decompose_custom(str, strlen, buffer, result, options, custom_func, custom_data); - if (result < 0) { - free(buffer); - return result; - } - result = utf8proc_reencode(buffer, result, options); - if (result < 0) { - free(buffer); - return result; - } - { - utf8proc_int32_t *newptr; - newptr = (utf8proc_int32_t *) realloc(buffer, (size_t)result+1); - if (newptr) buffer = newptr; - } - *dstptr = (utf8proc_uint8_t *)buffer; - return result; -} - -UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFD(const utf8proc_uint8_t *str, utf8proc_ssize_t len) { - utf8proc_uint8_t *retval; - utf8proc_map(str, len, &retval, (utf8proc_option_t)(UTF8PROC_STABLE | - UTF8PROC_DECOMPOSE)); - return retval; -} - -UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFC(const utf8proc_uint8_t *str, utf8proc_ssize_t len) { - utf8proc_uint8_t *retval; - utf8proc_map(str, len, &retval, (utf8proc_option_t)(UTF8PROC_STABLE | - UTF8PROC_COMPOSE)); - return retval; + utf8proc_int32_t *buffer; + utf8proc_ssize_t result; + *dstptr = NULL; + result = utf8proc_decompose_custom(str, strlen, NULL, 0, options, custom_func, custom_data); + if (result < 0) return result; + buffer = (utf8proc_int32_t *) malloc(((utf8proc_size_t)result) * sizeof(utf8proc_int32_t) + 1); + if (!buffer) return UTF8PROC_ERROR_NOMEM; + result = utf8proc_decompose_custom(str, strlen, buffer, result, options, custom_func, custom_data); + if (result < 0) { + free(buffer); + return result; + } + result = utf8proc_reencode(buffer, result, options); + if (result < 0) { + free(buffer); + return result; + } + { + utf8proc_int32_t *newptr; + newptr = (utf8proc_int32_t *) realloc(buffer, (size_t)result+1); + if (newptr) buffer = newptr; + } + *dstptr = (utf8proc_uint8_t *)buffer; + return result; +} + +UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFD(const utf8proc_uint8_t *str, utf8proc_ssize_t strlen) { + utf8proc_uint8_t *retval; + utf8proc_map(str, strlen, &retval, utf8proc_option_t(UTF8PROC_STABLE | + UTF8PROC_DECOMPOSE)); + return retval; +} + +UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFC(const utf8proc_uint8_t *str, utf8proc_ssize_t strlen) { + utf8proc_uint8_t *retval; + utf8proc_map(str, strlen, &retval, utf8proc_option_t(UTF8PROC_STABLE | + UTF8PROC_COMPOSE)); + return retval; +} + +UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFKD(const utf8proc_uint8_t *str, utf8proc_ssize_t strlen) { + utf8proc_uint8_t *retval; + utf8proc_map(str, strlen, &retval, utf8proc_option_t(UTF8PROC_STABLE | + UTF8PROC_DECOMPOSE | UTF8PROC_COMPAT)); + return retval; } UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_remove_accents(const utf8proc_uint8_t *str, utf8proc_ssize_t len) { @@ -852,25 +808,18 @@ UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_remove_accents(const utf8proc_uint return retval; } -UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFKD(const utf8proc_uint8_t *str, utf8proc_ssize_t len) { - utf8proc_uint8_t *retval; - utf8proc_map(str, len, &retval, (utf8proc_option_t)(UTF8PROC_STABLE | - UTF8PROC_DECOMPOSE | UTF8PROC_COMPAT)); - return retval; +UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFKC(const utf8proc_uint8_t *str, utf8proc_ssize_t strlen) { + utf8proc_uint8_t *retval; + utf8proc_map(str, strlen, &retval, utf8proc_option_t(UTF8PROC_STABLE | + UTF8PROC_COMPOSE | UTF8PROC_COMPAT)); + return retval; } -UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFKC(const utf8proc_uint8_t *str, utf8proc_ssize_t len) { - utf8proc_uint8_t *retval; - utf8proc_map(str, len, &retval, (utf8proc_option_t)(UTF8PROC_STABLE | - UTF8PROC_COMPOSE | UTF8PROC_COMPAT)); - return retval; -} - -UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFKC_Casefold(const utf8proc_uint8_t *str, utf8proc_ssize_t len) { - utf8proc_uint8_t *retval; - utf8proc_map(str, len, &retval, (utf8proc_option_t)(UTF8PROC_STABLE | - UTF8PROC_COMPOSE | UTF8PROC_COMPAT | UTF8PROC_CASEFOLD | UTF8PROC_IGNORE)); - return retval; +UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFKC_Casefold(const utf8proc_uint8_t *str, utf8proc_ssize_t strlen) { + utf8proc_uint8_t *retval; + utf8proc_map(str, strlen, &retval, utf8proc_option_t(UTF8PROC_STABLE | + UTF8PROC_COMPOSE | UTF8PROC_COMPAT | UTF8PROC_CASEFOLD | UTF8PROC_IGNORE)); + return retval; } } diff --git a/third_party/utf8proc/utf8proc_data.cpp b/third_party/utf8proc/utf8proc_data.cpp index 8b18c4be5fd..f2b0f5ce9b4 100644 --- a/third_party/utf8proc/utf8proc_data.cpp +++ b/third_party/utf8proc/utf8proc_data.cpp @@ -2,714 +2,922 @@ static const utf8proc_uint16_t utf8proc_sequences[] = { 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, 32, 32, 776, 32, 772, - 50, 51, 32, 769, 956, 32, 807, 49, - 49, 8260, 52, 49, 8260, 50, 51, 8260, - 52, 65, 768, 224, 65, 769, 225, 65, - 770, 226, 65, 771, 227, 65, 776, 228, - 65, 778, 229, 230, 67, 807, 231, 69, - 768, 232, 69, 769, 233, 69, 770, 234, - 69, 776, 235, 73, 768, 236, 73, 769, - 237, 73, 770, 238, 73, 776, 239, 240, - 78, 771, 241, 79, 768, 242, 79, 769, - 243, 79, 770, 244, 79, 771, 245, 79, - 776, 246, 248, 85, 768, 249, 85, 769, - 250, 85, 770, 251, 85, 776, 252, 89, - 769, 253, 254, 115, 115, 97, 768, 97, - 769, 97, 770, 97, 771, 97, 776, 97, - 778, 99, 807, 101, 768, 101, 769, 101, - 770, 101, 776, 105, 768, 105, 769, 105, - 770, 105, 776, 110, 771, 111, 768, 111, - 769, 111, 770, 111, 771, 111, 776, 117, - 768, 117, 769, 117, 770, 117, 776, 121, - 769, 121, 776, 65, 772, 257, 97, 772, - 65, 774, 259, 97, 774, 65, 808, 261, - 97, 808, 67, 769, 263, 99, 769, 67, - 770, 265, 99, 770, 67, 775, 267, 99, - 775, 67, 780, 269, 99, 780, 68, 780, - 271, 100, 780, 273, 69, 772, 275, 101, - 772, 69, 774, 277, 101, 774, 69, 775, - 279, 101, 775, 69, 808, 281, 101, 808, - 69, 780, 283, 101, 780, 71, 770, 285, - 103, 770, 71, 774, 287, 103, 774, 71, - 775, 289, 103, 775, 71, 807, 291, 103, - 807, 72, 770, 293, 104, 770, 295, 73, - 771, 297, 105, 771, 73, 772, 299, 105, - 772, 73, 774, 301, 105, 774, 73, 808, - 303, 105, 808, 73, 775, 105, 775, 73, - 74, 307, 105, 106, 74, 770, 309, 106, - 770, 75, 807, 311, 107, 807, 76, 769, - 314, 108, 769, 76, 807, 316, 108, 807, - 76, 780, 318, 108, 780, 76, 183, 320, - 108, 183, 322, 78, 769, 324, 110, 769, - 78, 807, 326, 110, 807, 78, 780, 328, - 110, 780, 700, 110, 331, 79, 772, 333, - 111, 772, 79, 774, 335, 111, 774, 79, - 779, 337, 111, 779, 339, 82, 769, 341, - 114, 769, 82, 807, 343, 114, 807, 82, - 780, 345, 114, 780, 83, 769, 347, 115, - 769, 83, 770, 349, 115, 770, 83, 807, - 351, 115, 807, 83, 780, 353, 115, 780, - 84, 807, 355, 116, 807, 84, 780, 357, - 116, 780, 359, 85, 771, 361, 117, 771, - 85, 772, 363, 117, 772, 85, 774, 365, - 117, 774, 85, 778, 367, 117, 778, 85, - 779, 369, 117, 779, 85, 808, 371, 117, - 808, 87, 770, 373, 119, 770, 89, 770, - 375, 121, 770, 89, 776, 255, 90, 769, - 378, 122, 769, 90, 775, 380, 122, 775, - 90, 780, 382, 122, 780, 595, 387, 389, - 596, 392, 598, 599, 396, 477, 601, 603, - 402, 608, 611, 617, 616, 409, 623, 626, - 629, 79, 795, 417, 111, 795, 419, 421, - 640, 424, 643, 429, 648, 85, 795, 432, - 117, 795, 650, 651, 436, 438, 658, 441, - 445, 68, 381, 454, 68, 382, 100, 382, - 76, 74, 457, 76, 106, 108, 106, 78, - 74, 460, 78, 106, 110, 106, 65, 780, - 462, 97, 780, 73, 780, 464, 105, 780, - 79, 780, 466, 111, 780, 85, 780, 468, - 117, 780, 220, 772, 470, 252, 772, 220, - 769, 472, 252, 769, 220, 780, 474, 252, - 780, 220, 768, 476, 252, 768, 196, 772, - 479, 228, 772, 550, 772, 481, 551, 772, - 198, 772, 483, 230, 772, 485, 71, 780, - 487, 103, 780, 75, 780, 489, 107, 780, - 79, 808, 491, 111, 808, 490, 772, 493, - 491, 772, 439, 780, 495, 658, 780, 106, - 780, 68, 90, 499, 68, 122, 100, 122, - 71, 769, 501, 103, 769, 405, 447, 78, - 768, 505, 110, 768, 197, 769, 507, 229, - 769, 198, 769, 509, 230, 769, 216, 769, - 511, 248, 769, 65, 783, 513, 97, 783, - 65, 785, 515, 97, 785, 69, 783, 517, - 101, 783, 69, 785, 519, 101, 785, 73, - 783, 521, 105, 783, 73, 785, 523, 105, - 785, 79, 783, 525, 111, 783, 79, 785, - 527, 111, 785, 82, 783, 529, 114, 783, - 82, 785, 531, 114, 785, 85, 783, 533, - 117, 783, 85, 785, 535, 117, 785, 83, - 806, 537, 115, 806, 84, 806, 539, 116, - 806, 541, 72, 780, 543, 104, 780, 414, - 547, 549, 65, 775, 551, 97, 775, 69, - 807, 553, 101, 807, 214, 772, 555, 246, - 772, 213, 772, 557, 245, 772, 79, 775, - 559, 111, 775, 558, 772, 561, 559, 772, - 89, 772, 563, 121, 772, 11365, 572, 410, - 11366, 578, 384, 649, 652, 583, 585, 587, - 589, 591, 614, 633, 635, 641, 32, 774, - 32, 775, 32, 778, 32, 808, 32, 771, - 32, 779, 661, 768, 769, 787, 776, 769, - 953, 881, 883, 697, 887, 32, 837, 59, - 1011, 168, 769, 913, 769, 940, 183, 917, - 769, 941, 919, 769, 942, 921, 769, 943, - 927, 769, 972, 933, 769, 973, 937, 769, - 974, 970, 769, 953, 776, 769, 945, 946, - 947, 948, 949, 950, 951, 952, 954, 955, - 957, 958, 959, 960, 961, 963, 964, 965, - 966, 967, 968, 969, 921, 776, 970, 933, - 776, 971, 945, 769, 949, 769, 951, 769, - 953, 769, 971, 769, 965, 776, 769, 953, - 776, 965, 776, 959, 769, 965, 769, 969, - 769, 983, 933, 978, 769, 978, 776, 985, - 987, 989, 991, 993, 995, 997, 999, 1001, - 1003, 1005, 1007, 962, 920, 1016, 931, 1010, - 1019, 891, 892, 893, 1045, 768, 1104, 1045, - 776, 1105, 1106, 1043, 769, 1107, 1108, 1109, - 1110, 1030, 776, 1111, 1112, 1113, 1114, 1115, - 1050, 769, 1116, 1048, 768, 1117, 1059, 774, - 1118, 1119, 1072, 1073, 1074, 1075, 1076, 1077, - 1078, 1079, 1080, 1048, 774, 1081, 1082, 1083, - 1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091, - 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, - 1100, 1101, 1102, 1103, 1080, 774, 1077, 768, - 1077, 776, 1075, 769, 1110, 776, 1082, 769, - 1080, 768, 1091, 774, 1121, 1123, 1125, 1127, - 1129, 1131, 1133, 1135, 1137, 1139, 1141, 1140, - 783, 1143, 1141, 783, 1145, 1147, 1149, 1151, - 1153, 1163, 1165, 1167, 1169, 1171, 1173, 1175, - 1177, 1179, 1181, 1183, 1185, 1187, 1189, 1191, - 1193, 1195, 1197, 1199, 1201, 1203, 1205, 1207, - 1209, 1211, 1213, 1215, 1231, 1046, 774, 1218, - 1078, 774, 1220, 1222, 1224, 1226, 1228, 1230, - 1040, 774, 1233, 1072, 774, 1040, 776, 1235, - 1072, 776, 1237, 1045, 774, 1239, 1077, 774, - 1241, 1240, 776, 1243, 1241, 776, 1046, 776, - 1245, 1078, 776, 1047, 776, 1247, 1079, 776, - 1249, 1048, 772, 1251, 1080, 772, 1048, 776, - 1253, 1080, 776, 1054, 776, 1255, 1086, 776, - 1257, 1256, 776, 1259, 1257, 776, 1069, 776, - 1261, 1101, 776, 1059, 772, 1263, 1091, 772, - 1059, 776, 1265, 1091, 776, 1059, 779, 1267, - 1091, 779, 1063, 776, 1269, 1095, 776, 1271, - 1067, 776, 1273, 1099, 776, 1275, 1277, 1279, - 1281, 1283, 1285, 1287, 1289, 1291, 1293, 1295, - 1297, 1299, 1301, 1303, 1305, 1307, 1309, 1311, - 1313, 1315, 1317, 1319, 1321, 1323, 1325, 1327, - 1377, 1378, 1379, 1380, 1381, 1382, 1383, 1384, - 1385, 1386, 1387, 1388, 1389, 1390, 1391, 1392, - 1393, 1394, 1395, 1396, 1397, 1398, 1399, 1400, - 1401, 1402, 1403, 1404, 1405, 1406, 1407, 1408, - 1409, 1410, 1411, 1412, 1413, 1414, 1381, 1410, - 1575, 1619, 1575, 1620, 1608, 1620, 1575, 1621, - 1610, 1620, 1575, 1652, 1608, 1652, 1735, 1652, - 1610, 1652, 1749, 1620, 1729, 1620, 1746, 1620, - 2344, 2364, 2352, 2364, 2355, 2364, 2325, 2364, - 2326, 2364, 2327, 2364, 2332, 2364, 2337, 2364, - 2338, 2364, 2347, 2364, 2351, 2364, 2503, 2494, - 2503, 2519, 2465, 2492, 2466, 2492, 2479, 2492, - 2610, 2620, 2616, 2620, 2582, 2620, 2583, 2620, - 2588, 2620, 2603, 2620, 2887, 2902, 2887, 2878, - 2887, 2903, 2849, 2876, 2850, 2876, 2962, 3031, - 3014, 3006, 3015, 3006, 3014, 3031, 3142, 3158, - 3263, 3285, 3270, 3285, 3270, 3286, 3270, 3266, - 3274, 3285, 3398, 3390, 3399, 3390, 3398, 3415, - 3545, 3530, 3545, 3535, 3548, 3530, 3545, 3551, - 3661, 3634, 3789, 3762, 3755, 3737, 3755, 3745, - 3851, 3906, 4023, 3916, 4023, 3921, 4023, 3926, - 4023, 3931, 4023, 3904, 4021, 3953, 3954, 3953, - 3956, 4018, 3968, 4018, 3969, 4019, 3968, 4019, - 3969, 3953, 3968, 3986, 4023, 3996, 4023, 4001, - 4023, 4006, 4023, 4011, 4023, 3984, 4021, 4133, - 4142, 11520, 11521, 11522, 11523, 11524, 11525, 11526, - 11527, 11528, 11529, 11530, 11531, 11532, 11533, 11534, - 11535, 11536, 11537, 11538, 11539, 11540, 11541, 11542, - 11543, 11544, 11545, 11546, 11547, 11548, 11549, 11550, - 11551, 11552, 11553, 11554, 11555, 11556, 11557, 11559, - 11565, 4316, 5104, 5105, 5106, 5107, 5108, 5109, - 6917, 6965, 6919, 6965, 6921, 6965, 6923, 6965, - 6925, 6965, 6929, 6965, 6970, 6965, 6972, 6965, - 6974, 6965, 6975, 6965, 6978, 6965, 42571, 4304, - 4305, 4306, 4307, 4308, 4309, 4310, 4311, 4312, - 4313, 4314, 4315, 4317, 4318, 4319, 4320, 4321, - 4322, 4323, 4324, 4325, 4326, 4327, 4328, 4329, - 4330, 4331, 4332, 4333, 4334, 4335, 4336, 4337, - 4338, 4339, 4340, 4341, 4342, 4343, 4344, 4345, - 4346, 4349, 4350, 4351, 65, 198, 66, 68, - 69, 398, 71, 72, 73, 74, 75, 76, - 77, 78, 79, 546, 80, 82, 84, 85, - 87, 592, 593, 7426, 604, 7446, 7447, 7453, - 7461, 594, 597, 607, 609, 613, 618, 7547, - 669, 621, 7557, 671, 625, 624, 627, 628, - 632, 642, 427, 7452, 656, 657, 65, 805, - 7681, 97, 805, 66, 775, 7683, 98, 775, - 66, 803, 7685, 98, 803, 66, 817, 7687, - 98, 817, 199, 769, 7689, 231, 769, 68, - 775, 7691, 100, 775, 68, 803, 7693, 100, - 803, 68, 817, 7695, 100, 817, 68, 807, - 7697, 100, 807, 68, 813, 7699, 100, 813, - 274, 768, 7701, 275, 768, 274, 769, 7703, - 275, 769, 69, 813, 7705, 101, 813, 69, - 816, 7707, 101, 816, 552, 774, 7709, 553, - 774, 70, 775, 7711, 102, 775, 71, 772, - 7713, 103, 772, 72, 775, 7715, 104, 775, - 72, 803, 7717, 104, 803, 72, 776, 7719, - 104, 776, 72, 807, 7721, 104, 807, 72, - 814, 7723, 104, 814, 73, 816, 7725, 105, - 816, 207, 769, 7727, 239, 769, 75, 769, - 7729, 107, 769, 75, 803, 7731, 107, 803, - 75, 817, 7733, 107, 817, 76, 803, 7735, - 108, 803, 7734, 772, 7737, 7735, 772, 76, - 817, 7739, 108, 817, 76, 813, 7741, 108, - 813, 77, 769, 7743, 109, 769, 77, 775, - 7745, 109, 775, 77, 803, 7747, 109, 803, - 78, 775, 7749, 110, 775, 78, 803, 7751, - 110, 803, 78, 817, 7753, 110, 817, 78, - 813, 7755, 110, 813, 213, 769, 7757, 245, - 769, 213, 776, 7759, 245, 776, 332, 768, - 7761, 333, 768, 332, 769, 7763, 333, 769, - 80, 769, 7765, 112, 769, 80, 775, 7767, - 112, 775, 82, 775, 7769, 114, 775, 82, - 803, 7771, 114, 803, 7770, 772, 7773, 7771, - 772, 82, 817, 7775, 114, 817, 83, 775, - 7777, 115, 775, 83, 803, 7779, 115, 803, - 346, 775, 7781, 347, 775, 352, 775, 7783, - 353, 775, 7778, 775, 7785, 7779, 775, 84, - 775, 7787, 116, 775, 84, 803, 7789, 116, - 803, 84, 817, 7791, 116, 817, 84, 813, - 7793, 116, 813, 85, 804, 7795, 117, 804, - 85, 816, 7797, 117, 816, 85, 813, 7799, - 117, 813, 360, 769, 7801, 361, 769, 362, - 776, 7803, 363, 776, 86, 771, 7805, 118, - 771, 86, 803, 7807, 118, 803, 87, 768, - 7809, 119, 768, 87, 769, 7811, 119, 769, - 87, 776, 7813, 119, 776, 87, 775, 7815, - 119, 775, 87, 803, 7817, 119, 803, 88, - 775, 7819, 120, 775, 88, 776, 7821, 120, - 776, 89, 775, 7823, 121, 775, 90, 770, - 7825, 122, 770, 90, 803, 7827, 122, 803, - 90, 817, 7829, 122, 817, 104, 817, 116, - 776, 119, 778, 121, 778, 97, 702, 383, - 775, 65, 803, 7841, 97, 803, 65, 777, - 7843, 97, 777, 194, 769, 7845, 226, 769, - 194, 768, 7847, 226, 768, 194, 777, 7849, - 226, 777, 194, 771, 7851, 226, 771, 7840, - 770, 7853, 7841, 770, 258, 769, 7855, 259, - 769, 258, 768, 7857, 259, 768, 258, 777, - 7859, 259, 777, 258, 771, 7861, 259, 771, - 7840, 774, 7863, 7841, 774, 69, 803, 7865, - 101, 803, 69, 777, 7867, 101, 777, 69, - 771, 7869, 101, 771, 202, 769, 7871, 234, - 769, 202, 768, 7873, 234, 768, 202, 777, - 7875, 234, 777, 202, 771, 7877, 234, 771, - 7864, 770, 7879, 7865, 770, 73, 777, 7881, - 105, 777, 73, 803, 7883, 105, 803, 79, - 803, 7885, 111, 803, 79, 777, 7887, 111, - 777, 212, 769, 7889, 244, 769, 212, 768, - 7891, 244, 768, 212, 777, 7893, 244, 777, - 212, 771, 7895, 244, 771, 7884, 770, 7897, - 7885, 770, 416, 769, 7899, 417, 769, 416, - 768, 7901, 417, 768, 416, 777, 7903, 417, - 777, 416, 771, 7905, 417, 771, 416, 803, - 7907, 417, 803, 85, 803, 7909, 117, 803, - 85, 777, 7911, 117, 777, 431, 769, 7913, - 432, 769, 431, 768, 7915, 432, 768, 431, - 777, 7917, 432, 777, 431, 771, 7919, 432, - 771, 431, 803, 7921, 432, 803, 89, 768, - 7923, 121, 768, 89, 803, 7925, 121, 803, - 89, 777, 7927, 121, 777, 89, 771, 7929, - 121, 771, 7931, 7933, 7935, 945, 787, 945, - 788, 7936, 768, 7937, 768, 7936, 769, 7937, - 769, 7936, 834, 7937, 834, 913, 787, 7936, - 913, 788, 7937, 7944, 768, 7938, 7945, 768, - 7939, 7944, 769, 7940, 7945, 769, 7941, 7944, - 834, 7942, 7945, 834, 7943, 949, 787, 949, - 788, 7952, 768, 7953, 768, 7952, 769, 7953, - 769, 917, 787, 7952, 917, 788, 7953, 7960, - 768, 7954, 7961, 768, 7955, 7960, 769, 7956, - 7961, 769, 7957, 951, 787, 951, 788, 7968, - 768, 7969, 768, 7968, 769, 7969, 769, 7968, - 834, 7969, 834, 919, 787, 7968, 919, 788, - 7969, 7976, 768, 7970, 7977, 768, 7971, 7976, - 769, 7972, 7977, 769, 7973, 7976, 834, 7974, - 7977, 834, 7975, 953, 787, 953, 788, 7984, - 768, 7985, 768, 7984, 769, 7985, 769, 7984, - 834, 7985, 834, 921, 787, 7984, 921, 788, - 7985, 7992, 768, 7986, 7993, 768, 7987, 7992, - 769, 7988, 7993, 769, 7989, 7992, 834, 7990, - 7993, 834, 7991, 959, 787, 959, 788, 8000, - 768, 8001, 768, 8000, 769, 8001, 769, 927, - 787, 8000, 927, 788, 8001, 8008, 768, 8002, - 8009, 768, 8003, 8008, 769, 8004, 8009, 769, - 8005, 965, 787, 965, 788, 8016, 768, 965, - 787, 768, 8017, 768, 8016, 769, 965, 787, - 769, 8017, 769, 8016, 834, 965, 787, 834, - 8017, 834, 933, 788, 8017, 8025, 768, 8019, - 8025, 769, 8021, 8025, 834, 8023, 969, 787, - 969, 788, 8032, 768, 8033, 768, 8032, 769, - 8033, 769, 8032, 834, 8033, 834, 937, 787, - 8032, 937, 788, 8033, 8040, 768, 8034, 8041, - 768, 8035, 8040, 769, 8036, 8041, 769, 8037, - 8040, 834, 8038, 8041, 834, 8039, 945, 768, - 949, 768, 951, 768, 953, 768, 959, 768, - 965, 768, 969, 768, 7936, 837, 7936, 953, - 7937, 837, 7937, 953, 7938, 837, 7938, 953, - 7939, 837, 7939, 953, 7940, 837, 7940, 953, - 7941, 837, 7941, 953, 7942, 837, 7942, 953, - 7943, 837, 7943, 953, 7944, 837, 7945, 837, - 7946, 837, 7947, 837, 7948, 837, 7949, 837, - 7950, 837, 7951, 837, 7968, 837, 7968, 953, - 7969, 837, 7969, 953, 7970, 837, 7970, 953, - 7971, 837, 7971, 953, 7972, 837, 7972, 953, - 7973, 837, 7973, 953, 7974, 837, 7974, 953, - 7975, 837, 7975, 953, 7976, 837, 7977, 837, - 7978, 837, 7979, 837, 7980, 837, 7981, 837, - 7982, 837, 7983, 837, 8032, 837, 8032, 953, - 8033, 837, 8033, 953, 8034, 837, 8034, 953, - 8035, 837, 8035, 953, 8036, 837, 8036, 953, - 8037, 837, 8037, 953, 8038, 837, 8038, 953, - 8039, 837, 8039, 953, 8040, 837, 8041, 837, - 8042, 837, 8043, 837, 8044, 837, 8045, 837, - 8046, 837, 8047, 837, 945, 774, 945, 772, - 8048, 837, 8048, 953, 945, 837, 945, 953, - 940, 837, 940, 953, 945, 834, 8118, 837, - 945, 834, 953, 913, 774, 8112, 913, 772, - 8113, 913, 768, 8048, 902, 8049, 913, 837, - 32, 787, 32, 834, 168, 834, 8052, 837, - 8052, 953, 951, 837, 951, 953, 942, 837, - 942, 953, 951, 834, 8134, 837, 951, 834, - 953, 917, 768, 8050, 904, 8051, 919, 768, - 8052, 905, 8053, 919, 837, 8127, 768, 8127, - 769, 8127, 834, 953, 774, 953, 772, 970, - 768, 953, 776, 768, 912, 953, 834, 970, - 834, 953, 776, 834, 921, 774, 8144, 921, - 772, 8145, 921, 768, 8054, 906, 8055, 8190, - 768, 8190, 769, 8190, 834, 965, 774, 965, - 772, 971, 768, 965, 776, 768, 944, 961, - 787, 961, 788, 965, 834, 971, 834, 965, - 776, 834, 933, 774, 8160, 933, 772, 8161, - 933, 768, 8058, 910, 8059, 929, 788, 8165, - 168, 768, 901, 96, 8060, 837, 8060, 953, - 969, 837, 969, 953, 974, 837, 974, 953, - 969, 834, 8182, 837, 969, 834, 953, 927, - 768, 8056, 908, 8057, 937, 768, 8060, 911, - 8061, 937, 837, 180, 32, 788, 8194, 8195, + 120, 121, 122, 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, 32, 32, 776, + 170, 32, 772, 50, 51, 32, 769, 956, + 924, 32, 807, 49, 186, 49, 8260, 52, + 49, 8260, 50, 51, 8260, 52, 65, 768, + 224, 65, 769, 225, 65, 770, 226, 65, + 771, 227, 65, 776, 228, 65, 778, 229, + 230, 67, 807, 231, 69, 768, 232, 69, + 769, 233, 69, 770, 234, 69, 776, 235, + 73, 768, 236, 73, 769, 237, 73, 770, + 238, 73, 776, 239, 240, 78, 771, 241, + 79, 768, 242, 79, 769, 243, 79, 770, + 244, 79, 771, 245, 79, 776, 246, 248, + 85, 768, 249, 85, 769, 250, 85, 770, + 251, 85, 776, 252, 89, 769, 253, 254, + 115, 115, 7838, 97, 768, 192, 97, 769, + 193, 97, 770, 194, 97, 771, 195, 97, + 776, 196, 97, 778, 197, 198, 99, 807, + 199, 101, 768, 200, 101, 769, 201, 101, + 770, 202, 101, 776, 203, 105, 768, 204, + 105, 769, 205, 105, 770, 206, 105, 776, + 207, 208, 110, 771, 209, 111, 768, 210, + 111, 769, 211, 111, 770, 212, 111, 771, + 213, 111, 776, 214, 216, 117, 768, 217, + 117, 769, 218, 117, 770, 219, 117, 776, + 220, 121, 769, 221, 222, 121, 776, 376, + 65, 772, 257, 97, 772, 256, 65, 774, + 259, 97, 774, 258, 65, 808, 261, 97, + 808, 260, 67, 769, 263, 99, 769, 262, + 67, 770, 265, 99, 770, 264, 67, 775, + 267, 99, 775, 266, 67, 780, 269, 99, + 780, 268, 68, 780, 271, 100, 780, 270, + 273, 272, 69, 772, 275, 101, 772, 274, + 69, 774, 277, 101, 774, 276, 69, 775, + 279, 101, 775, 278, 69, 808, 281, 101, + 808, 280, 69, 780, 283, 101, 780, 282, + 71, 770, 285, 103, 770, 284, 71, 774, + 287, 103, 774, 286, 71, 775, 289, 103, + 775, 288, 71, 807, 291, 103, 807, 290, + 72, 770, 293, 104, 770, 292, 295, 294, + 73, 771, 297, 105, 771, 296, 73, 772, + 299, 105, 772, 298, 73, 774, 301, 105, + 774, 300, 73, 808, 303, 105, 808, 302, + 73, 775, 105, 775, 73, 74, 307, 105, + 106, 306, 74, 770, 309, 106, 770, 308, + 75, 807, 311, 107, 807, 310, 312, 76, + 769, 314, 108, 769, 313, 76, 807, 316, + 108, 807, 315, 76, 780, 318, 108, 780, + 317, 76, 183, 320, 108, 183, 319, 322, + 321, 78, 769, 324, 110, 769, 323, 78, + 807, 326, 110, 807, 325, 78, 780, 328, + 110, 780, 327, 700, 110, 329, 331, 330, + 79, 772, 333, 111, 772, 332, 79, 774, + 335, 111, 774, 334, 79, 779, 337, 111, + 779, 336, 339, 338, 82, 769, 341, 114, + 769, 340, 82, 807, 343, 114, 807, 342, + 82, 780, 345, 114, 780, 344, 83, 769, + 347, 115, 769, 346, 83, 770, 349, 115, + 770, 348, 83, 807, 351, 115, 807, 350, + 83, 780, 353, 115, 780, 352, 84, 807, + 355, 116, 807, 354, 84, 780, 357, 116, + 780, 356, 359, 358, 85, 771, 361, 117, + 771, 360, 85, 772, 363, 117, 772, 362, + 85, 774, 365, 117, 774, 364, 85, 778, + 367, 117, 778, 366, 85, 779, 369, 117, + 779, 368, 85, 808, 371, 117, 808, 370, + 87, 770, 373, 119, 770, 372, 89, 770, + 375, 121, 770, 374, 89, 776, 255, 90, + 769, 378, 122, 769, 377, 90, 775, 380, + 122, 775, 379, 90, 780, 382, 122, 780, + 381, 579, 595, 387, 386, 389, 388, 596, + 392, 391, 598, 599, 396, 395, 397, 477, + 601, 603, 402, 401, 608, 611, 502, 617, + 616, 409, 408, 573, 411, 623, 626, 544, + 629, 79, 795, 417, 111, 795, 416, 419, + 418, 421, 420, 640, 424, 423, 643, 426, + 427, 429, 428, 648, 85, 795, 432, 117, + 795, 431, 650, 651, 436, 435, 438, 437, + 658, 441, 440, 442, 445, 444, 446, 503, + 68, 381, 454, 453, 68, 382, 452, 100, + 382, 76, 74, 457, 456, 76, 106, 455, + 108, 106, 78, 74, 460, 459, 78, 106, + 458, 110, 106, 65, 780, 462, 97, 780, + 461, 73, 780, 464, 105, 780, 463, 79, + 780, 466, 111, 780, 465, 85, 780, 468, + 117, 780, 467, 220, 772, 470, 252, 772, + 469, 220, 769, 472, 252, 769, 471, 220, + 780, 474, 252, 780, 473, 220, 768, 476, + 252, 768, 475, 398, 196, 772, 479, 228, + 772, 478, 550, 772, 481, 551, 772, 480, + 198, 772, 483, 230, 772, 482, 485, 484, + 71, 780, 487, 103, 780, 486, 75, 780, + 489, 107, 780, 488, 79, 808, 491, 111, + 808, 490, 490, 772, 493, 491, 772, 492, + 439, 780, 495, 658, 780, 494, 106, 780, + 496, 68, 90, 499, 498, 68, 122, 497, + 100, 122, 71, 769, 501, 103, 769, 500, + 405, 447, 78, 768, 505, 110, 768, 504, + 197, 769, 507, 229, 769, 506, 198, 769, + 509, 230, 769, 508, 216, 769, 511, 248, + 769, 510, 65, 783, 513, 97, 783, 512, + 65, 785, 515, 97, 785, 514, 69, 783, + 517, 101, 783, 516, 69, 785, 519, 101, + 785, 518, 73, 783, 521, 105, 783, 520, + 73, 785, 523, 105, 785, 522, 79, 783, + 525, 111, 783, 524, 79, 785, 527, 111, + 785, 526, 82, 783, 529, 114, 783, 528, + 82, 785, 531, 114, 785, 530, 85, 783, + 533, 117, 783, 532, 85, 785, 535, 117, + 785, 534, 83, 806, 537, 115, 806, 536, + 84, 806, 539, 116, 806, 538, 541, 540, + 72, 780, 543, 104, 780, 542, 414, 545, + 547, 546, 549, 548, 65, 775, 551, 97, + 775, 550, 69, 807, 553, 101, 807, 552, + 214, 772, 555, 246, 772, 554, 213, 772, + 557, 245, 772, 556, 79, 775, 559, 111, + 775, 558, 558, 772, 561, 559, 772, 560, + 89, 772, 563, 121, 772, 562, 564, 565, + 566, 567, 568, 569, 11365, 572, 571, 410, + 11366, 11390, 11391, 578, 577, 384, 649, 652, + 583, 582, 585, 584, 587, 586, 589, 588, + 591, 590, 11375, 11373, 11376, 385, 390, 597, + 393, 394, 600, 399, 602, 400, 42923, 605, + 606, 607, 403, 42924, 610, 404, 612, 42893, + 42922, 615, 407, 406, 42926, 11362, 42925, 621, + 622, 412, 624, 11374, 413, 627, 628, 415, + 630, 631, 632, 633, 634, 635, 636, 11364, + 638, 639, 422, 641, 42949, 425, 644, 645, + 646, 42929, 430, 580, 433, 434, 581, 653, + 654, 655, 656, 657, 439, 659, 661, 662, + 663, 664, 665, 666, 667, 668, 42930, 42928, + 671, 672, 673, 674, 675, 676, 677, 678, + 679, 680, 681, 682, 683, 684, 685, 686, + 687, 688, 614, 689, 690, 691, 692, 693, + 694, 695, 696, 704, 705, 32, 774, 32, + 775, 32, 778, 32, 808, 32, 771, 32, + 779, 736, 737, 738, 739, 740, 768, 769, + 787, 776, 769, 953, 921, 881, 880, 883, + 882, 697, 887, 886, 32, 837, 890, 1021, + 1022, 1023, 59, 1011, 168, 769, 913, 769, + 940, 183, 917, 769, 941, 919, 769, 942, + 921, 769, 943, 927, 769, 972, 933, 769, + 973, 937, 769, 974, 970, 769, 953, 776, + 769, 912, 945, 946, 947, 948, 949, 950, + 951, 952, 954, 955, 957, 958, 959, 960, + 961, 963, 964, 965, 966, 967, 968, 969, + 921, 776, 970, 933, 776, 971, 945, 769, + 902, 949, 769, 904, 951, 769, 905, 953, + 769, 906, 971, 769, 965, 776, 769, 944, + 913, 914, 915, 916, 917, 918, 919, 920, + 922, 923, 925, 926, 927, 928, 929, 931, + 932, 933, 934, 935, 936, 937, 953, 776, + 938, 965, 776, 939, 959, 769, 908, 965, + 769, 910, 969, 769, 911, 983, 978, 978, + 769, 979, 978, 776, 980, 975, 985, 984, + 987, 986, 989, 988, 991, 990, 993, 992, + 995, 994, 997, 996, 999, 998, 1001, 1000, + 1003, 1002, 1005, 1004, 1007, 1006, 962, 1017, + 895, 1016, 1015, 1010, 1019, 1018, 1020, 891, + 892, 893, 1045, 768, 1104, 1045, 776, 1105, + 1106, 1043, 769, 1107, 1108, 1109, 1110, 1030, + 776, 1111, 1112, 1113, 1114, 1115, 1050, 769, + 1116, 1048, 768, 1117, 1059, 774, 1118, 1119, + 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, + 1080, 1048, 774, 1081, 1082, 1083, 1084, 1085, + 1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093, + 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, + 1102, 1103, 1040, 1041, 1042, 1043, 1044, 1045, + 1046, 1047, 1048, 1080, 774, 1049, 1050, 1051, + 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, + 1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, + 1068, 1069, 1070, 1071, 1077, 768, 1024, 1077, + 776, 1025, 1026, 1075, 769, 1027, 1028, 1029, + 1030, 1110, 776, 1031, 1032, 1033, 1034, 1035, + 1082, 769, 1036, 1080, 768, 1037, 1091, 774, + 1038, 1039, 1121, 1120, 1123, 1122, 1125, 1124, + 1127, 1126, 1129, 1128, 1131, 1130, 1133, 1132, + 1135, 1134, 1137, 1136, 1139, 1138, 1141, 1140, + 1140, 783, 1143, 1141, 783, 1142, 1145, 1144, + 1147, 1146, 1149, 1148, 1151, 1150, 1153, 1152, + 1163, 1162, 1165, 1164, 1167, 1166, 1169, 1168, + 1171, 1170, 1173, 1172, 1175, 1174, 1177, 1176, + 1179, 1178, 1181, 1180, 1183, 1182, 1185, 1184, + 1187, 1186, 1189, 1188, 1191, 1190, 1193, 1192, + 1195, 1194, 1197, 1196, 1199, 1198, 1201, 1200, + 1203, 1202, 1205, 1204, 1207, 1206, 1209, 1208, + 1211, 1210, 1213, 1212, 1215, 1214, 1231, 1046, + 774, 1218, 1078, 774, 1217, 1220, 1219, 1222, + 1221, 1224, 1223, 1226, 1225, 1228, 1227, 1230, + 1229, 1216, 1040, 774, 1233, 1072, 774, 1232, + 1040, 776, 1235, 1072, 776, 1234, 1237, 1236, + 1045, 774, 1239, 1077, 774, 1238, 1241, 1240, + 1240, 776, 1243, 1241, 776, 1242, 1046, 776, + 1245, 1078, 776, 1244, 1047, 776, 1247, 1079, + 776, 1246, 1249, 1248, 1048, 772, 1251, 1080, + 772, 1250, 1048, 776, 1253, 1080, 776, 1252, + 1054, 776, 1255, 1086, 776, 1254, 1257, 1256, + 1256, 776, 1259, 1257, 776, 1258, 1069, 776, + 1261, 1101, 776, 1260, 1059, 772, 1263, 1091, + 772, 1262, 1059, 776, 1265, 1091, 776, 1264, + 1059, 779, 1267, 1091, 779, 1266, 1063, 776, + 1269, 1095, 776, 1268, 1271, 1270, 1067, 776, + 1273, 1099, 776, 1272, 1275, 1274, 1277, 1276, + 1279, 1278, 1281, 1280, 1283, 1282, 1285, 1284, + 1287, 1286, 1289, 1288, 1291, 1290, 1293, 1292, + 1295, 1294, 1297, 1296, 1299, 1298, 1301, 1300, + 1303, 1302, 1305, 1304, 1307, 1306, 1309, 1308, + 1311, 1310, 1313, 1312, 1315, 1314, 1317, 1316, + 1319, 1318, 1321, 1320, 1323, 1322, 1325, 1324, + 1327, 1326, 1377, 1378, 1379, 1380, 1381, 1382, + 1383, 1384, 1385, 1386, 1387, 1388, 1389, 1390, + 1391, 1392, 1393, 1394, 1395, 1396, 1397, 1398, + 1399, 1400, 1401, 1402, 1403, 1404, 1405, 1406, + 1407, 1408, 1409, 1410, 1411, 1412, 1413, 1414, + 1376, 1329, 1330, 1331, 1332, 1333, 1334, 1335, + 1336, 1337, 1338, 1339, 1340, 1341, 1342, 1343, + 1344, 1345, 1346, 1347, 1348, 1349, 1350, 1351, + 1352, 1353, 1354, 1355, 1356, 1357, 1358, 1359, + 1360, 1361, 1362, 1363, 1364, 1365, 1366, 1381, + 1410, 1415, 1416, 1575, 1619, 1575, 1620, 1608, + 1620, 1575, 1621, 1610, 1620, 1575, 1652, 1608, + 1652, 1735, 1652, 1610, 1652, 1749, 1620, 1729, + 1620, 1746, 1620, 2344, 2364, 2352, 2364, 2355, + 2364, 2325, 2364, 2326, 2364, 2327, 2364, 2332, + 2364, 2337, 2364, 2338, 2364, 2347, 2364, 2351, + 2364, 2503, 2494, 2503, 2519, 2465, 2492, 2466, + 2492, 2479, 2492, 2610, 2620, 2616, 2620, 2582, + 2620, 2583, 2620, 2588, 2620, 2603, 2620, 2887, + 2902, 2887, 2878, 2887, 2903, 2849, 2876, 2850, + 2876, 2962, 3031, 3014, 3006, 3015, 3006, 3014, + 3031, 3142, 3158, 3263, 3285, 3270, 3285, 3270, + 3286, 3270, 3266, 3274, 3285, 3398, 3390, 3399, + 3390, 3398, 3415, 3545, 3530, 3545, 3535, 3548, + 3530, 3545, 3551, 3661, 3634, 3789, 3762, 3755, + 3737, 3755, 3745, 3851, 3906, 4023, 3916, 4023, + 3921, 4023, 3926, 4023, 3931, 4023, 3904, 4021, + 3953, 3954, 3953, 3956, 4018, 3968, 4018, 3969, + 4019, 3968, 4019, 3969, 3953, 3968, 3986, 4023, + 3996, 4023, 4001, 4023, 4006, 4023, 4011, 4023, + 3984, 4021, 4133, 4142, 11520, 11521, 11522, 11523, + 11524, 11525, 11526, 11527, 11528, 11529, 11530, 11531, + 11532, 11533, 11534, 11535, 11536, 11537, 11538, 11539, + 11540, 11541, 11542, 11543, 11544, 11545, 11546, 11547, + 11548, 11549, 11550, 11551, 11552, 11553, 11554, 11555, + 11556, 11557, 11559, 11565, 7312, 4304, 7313, 4305, + 7314, 4306, 7315, 4307, 7316, 4308, 7317, 4309, + 7318, 4310, 7319, 4311, 7320, 4312, 7321, 4313, + 7322, 4314, 7323, 4315, 7324, 4316, 7325, 4317, + 7326, 4318, 7327, 4319, 7328, 4320, 7329, 4321, + 7330, 4322, 7331, 4323, 7332, 4324, 7333, 4325, + 7334, 4326, 7335, 4327, 7336, 4328, 7337, 4329, + 7338, 4330, 7339, 4331, 7340, 4332, 7341, 4333, + 7342, 4334, 7343, 4335, 7344, 4336, 7345, 4337, + 7346, 4338, 7347, 4339, 7348, 4340, 7349, 4341, + 7350, 4342, 7351, 4343, 7352, 4344, 7353, 4345, + 7354, 4346, 4348, 7357, 4349, 7358, 4350, 7359, + 4351, 43888, 43889, 43890, 43891, 43892, 43893, 43894, + 43895, 43896, 43897, 43898, 43899, 43900, 43901, 43902, + 43903, 43904, 43905, 43906, 43907, 43908, 43909, 43910, + 43911, 43912, 43913, 43914, 43915, 43916, 43917, 43918, + 43919, 43920, 43921, 43922, 43923, 43924, 43925, 43926, + 43927, 43928, 43929, 43930, 43931, 43932, 43933, 43934, + 43935, 43936, 43937, 43938, 43939, 43940, 43941, 43942, + 43943, 43944, 43945, 43946, 43947, 43948, 43949, 43950, + 43951, 43952, 43953, 43954, 43955, 43956, 43957, 43958, + 43959, 43960, 43961, 43962, 43963, 43964, 43965, 43966, + 43967, 5112, 5113, 5114, 5115, 5116, 5117, 5104, + 5105, 5106, 5107, 5108, 5109, 6917, 6965, 6919, + 6965, 6921, 6965, 6923, 6965, 6925, 6965, 6929, + 6965, 6970, 6965, 6972, 6965, 6974, 6965, 6975, + 6965, 6978, 6965, 42571, 42570, 7424, 7425, 7426, + 7427, 7428, 7429, 7430, 7431, 7432, 7433, 7434, + 7435, 7436, 7437, 7438, 7439, 7440, 7441, 7442, + 7443, 7444, 7445, 7446, 7447, 7448, 7449, 7450, + 7451, 7452, 7453, 7454, 7455, 7456, 7457, 7458, + 7459, 7460, 7461, 7462, 7463, 7464, 7465, 7466, + 7467, 7468, 7469, 7470, 7471, 7472, 7473, 7474, + 7475, 7476, 7477, 7478, 7479, 7480, 7481, 7482, + 7483, 7484, 7485, 7486, 7487, 7488, 7489, 7490, + 7491, 592, 7492, 593, 7493, 7494, 7495, 7496, + 7497, 7498, 7499, 604, 7500, 7501, 7502, 7503, + 7504, 7505, 7506, 7507, 7508, 7509, 7510, 7511, + 7512, 7513, 7514, 7515, 7516, 7517, 7518, 7519, + 7520, 7521, 7522, 7523, 7524, 7525, 7526, 7527, + 7528, 7529, 7530, 7531, 7532, 7533, 7534, 7535, + 7536, 7537, 7538, 7539, 7540, 7541, 7542, 7543, + 7544, 42877, 7546, 7547, 7548, 11363, 7550, 7551, + 7552, 7553, 7554, 7555, 7556, 7557, 7558, 7559, + 7560, 7561, 7562, 7563, 7564, 7565, 42950, 7567, + 7568, 7569, 7570, 7571, 7572, 7573, 7574, 7575, + 7576, 7577, 7578, 594, 7579, 7580, 7581, 7582, + 7583, 7584, 7585, 609, 7586, 613, 7587, 7588, + 7589, 618, 7590, 7591, 669, 7592, 7593, 7594, + 7595, 625, 7596, 7597, 7598, 7599, 7600, 7601, + 7602, 642, 7603, 7604, 7605, 7606, 7607, 7608, + 7609, 7610, 7611, 7612, 7613, 7614, 7615, 65, + 805, 7681, 97, 805, 7680, 66, 775, 7683, + 98, 775, 7682, 66, 803, 7685, 98, 803, + 7684, 66, 817, 7687, 98, 817, 7686, 199, + 769, 7689, 231, 769, 7688, 68, 775, 7691, + 100, 775, 7690, 68, 803, 7693, 100, 803, + 7692, 68, 817, 7695, 100, 817, 7694, 68, + 807, 7697, 100, 807, 7696, 68, 813, 7699, + 100, 813, 7698, 274, 768, 7701, 275, 768, + 7700, 274, 769, 7703, 275, 769, 7702, 69, + 813, 7705, 101, 813, 7704, 69, 816, 7707, + 101, 816, 7706, 552, 774, 7709, 553, 774, + 7708, 70, 775, 7711, 102, 775, 7710, 71, + 772, 7713, 103, 772, 7712, 72, 775, 7715, + 104, 775, 7714, 72, 803, 7717, 104, 803, + 7716, 72, 776, 7719, 104, 776, 7718, 72, + 807, 7721, 104, 807, 7720, 72, 814, 7723, + 104, 814, 7722, 73, 816, 7725, 105, 816, + 7724, 207, 769, 7727, 239, 769, 7726, 75, + 769, 7729, 107, 769, 7728, 75, 803, 7731, + 107, 803, 7730, 75, 817, 7733, 107, 817, + 7732, 76, 803, 7735, 108, 803, 7734, 7734, + 772, 7737, 7735, 772, 7736, 76, 817, 7739, + 108, 817, 7738, 76, 813, 7741, 108, 813, + 7740, 77, 769, 7743, 109, 769, 7742, 77, + 775, 7745, 109, 775, 7744, 77, 803, 7747, + 109, 803, 7746, 78, 775, 7749, 110, 775, + 7748, 78, 803, 7751, 110, 803, 7750, 78, + 817, 7753, 110, 817, 7752, 78, 813, 7755, + 110, 813, 7754, 213, 769, 7757, 245, 769, + 7756, 213, 776, 7759, 245, 776, 7758, 332, + 768, 7761, 333, 768, 7760, 332, 769, 7763, + 333, 769, 7762, 80, 769, 7765, 112, 769, + 7764, 80, 775, 7767, 112, 775, 7766, 82, + 775, 7769, 114, 775, 7768, 82, 803, 7771, + 114, 803, 7770, 7770, 772, 7773, 7771, 772, + 7772, 82, 817, 7775, 114, 817, 7774, 83, + 775, 7777, 115, 775, 7776, 83, 803, 7779, + 115, 803, 7778, 346, 775, 7781, 347, 775, + 7780, 352, 775, 7783, 353, 775, 7782, 7778, + 775, 7785, 7779, 775, 7784, 84, 775, 7787, + 116, 775, 7786, 84, 803, 7789, 116, 803, + 7788, 84, 817, 7791, 116, 817, 7790, 84, + 813, 7793, 116, 813, 7792, 85, 804, 7795, + 117, 804, 7794, 85, 816, 7797, 117, 816, + 7796, 85, 813, 7799, 117, 813, 7798, 360, + 769, 7801, 361, 769, 7800, 362, 776, 7803, + 363, 776, 7802, 86, 771, 7805, 118, 771, + 7804, 86, 803, 7807, 118, 803, 7806, 87, + 768, 7809, 119, 768, 7808, 87, 769, 7811, + 119, 769, 7810, 87, 776, 7813, 119, 776, + 7812, 87, 775, 7815, 119, 775, 7814, 87, + 803, 7817, 119, 803, 7816, 88, 775, 7819, + 120, 775, 7818, 88, 776, 7821, 120, 776, + 7820, 89, 775, 7823, 121, 775, 7822, 90, + 770, 7825, 122, 770, 7824, 90, 803, 7827, + 122, 803, 7826, 90, 817, 7829, 122, 817, + 7828, 104, 817, 7830, 116, 776, 7831, 119, + 778, 7832, 121, 778, 7833, 97, 702, 7834, + 383, 775, 7836, 7837, 223, 7839, 65, 803, + 7841, 97, 803, 7840, 65, 777, 7843, 97, + 777, 7842, 194, 769, 7845, 226, 769, 7844, + 194, 768, 7847, 226, 768, 7846, 194, 777, + 7849, 226, 777, 7848, 194, 771, 7851, 226, + 771, 7850, 7840, 770, 7853, 7841, 770, 7852, + 258, 769, 7855, 259, 769, 7854, 258, 768, + 7857, 259, 768, 7856, 258, 777, 7859, 259, + 777, 7858, 258, 771, 7861, 259, 771, 7860, + 7840, 774, 7863, 7841, 774, 7862, 69, 803, + 7865, 101, 803, 7864, 69, 777, 7867, 101, + 777, 7866, 69, 771, 7869, 101, 771, 7868, + 202, 769, 7871, 234, 769, 7870, 202, 768, + 7873, 234, 768, 7872, 202, 777, 7875, 234, + 777, 7874, 202, 771, 7877, 234, 771, 7876, + 7864, 770, 7879, 7865, 770, 7878, 73, 777, + 7881, 105, 777, 7880, 73, 803, 7883, 105, + 803, 7882, 79, 803, 7885, 111, 803, 7884, + 79, 777, 7887, 111, 777, 7886, 212, 769, + 7889, 244, 769, 7888, 212, 768, 7891, 244, + 768, 7890, 212, 777, 7893, 244, 777, 7892, + 212, 771, 7895, 244, 771, 7894, 7884, 770, + 7897, 7885, 770, 7896, 416, 769, 7899, 417, + 769, 7898, 416, 768, 7901, 417, 768, 7900, + 416, 777, 7903, 417, 777, 7902, 416, 771, + 7905, 417, 771, 7904, 416, 803, 7907, 417, + 803, 7906, 85, 803, 7909, 117, 803, 7908, + 85, 777, 7911, 117, 777, 7910, 431, 769, + 7913, 432, 769, 7912, 431, 768, 7915, 432, + 768, 7914, 431, 777, 7917, 432, 777, 7916, + 431, 771, 7919, 432, 771, 7918, 431, 803, + 7921, 432, 803, 7920, 89, 768, 7923, 121, + 768, 7922, 89, 803, 7925, 121, 803, 7924, + 89, 777, 7927, 121, 777, 7926, 89, 771, + 7929, 121, 771, 7928, 7931, 7930, 7933, 7932, + 7935, 7934, 945, 787, 7944, 945, 788, 7945, + 7936, 768, 7946, 7937, 768, 7947, 7936, 769, + 7948, 7937, 769, 7949, 7936, 834, 7950, 7937, + 834, 7951, 913, 787, 7936, 913, 788, 7937, + 7944, 768, 7938, 7945, 768, 7939, 7944, 769, + 7940, 7945, 769, 7941, 7944, 834, 7942, 7945, + 834, 7943, 949, 787, 7960, 949, 788, 7961, + 7952, 768, 7962, 7953, 768, 7963, 7952, 769, + 7964, 7953, 769, 7965, 917, 787, 7952, 917, + 788, 7953, 7960, 768, 7954, 7961, 768, 7955, + 7960, 769, 7956, 7961, 769, 7957, 951, 787, + 7976, 951, 788, 7977, 7968, 768, 7978, 7969, + 768, 7979, 7968, 769, 7980, 7969, 769, 7981, + 7968, 834, 7982, 7969, 834, 7983, 919, 787, + 7968, 919, 788, 7969, 7976, 768, 7970, 7977, + 768, 7971, 7976, 769, 7972, 7977, 769, 7973, + 7976, 834, 7974, 7977, 834, 7975, 953, 787, + 7992, 953, 788, 7993, 7984, 768, 7994, 7985, + 768, 7995, 7984, 769, 7996, 7985, 769, 7997, + 7984, 834, 7998, 7985, 834, 7999, 921, 787, + 7984, 921, 788, 7985, 7992, 768, 7986, 7993, + 768, 7987, 7992, 769, 7988, 7993, 769, 7989, + 7992, 834, 7990, 7993, 834, 7991, 959, 787, + 8008, 959, 788, 8009, 8000, 768, 8010, 8001, + 768, 8011, 8000, 769, 8012, 8001, 769, 8013, + 927, 787, 8000, 927, 788, 8001, 8008, 768, + 8002, 8009, 768, 8003, 8008, 769, 8004, 8009, + 769, 8005, 965, 787, 8016, 965, 788, 8025, + 8016, 768, 965, 787, 768, 8018, 8017, 768, + 8027, 8016, 769, 965, 787, 769, 8020, 8017, + 769, 8029, 8016, 834, 965, 787, 834, 8022, + 8017, 834, 8031, 933, 788, 8017, 8025, 768, + 8019, 8025, 769, 8021, 8025, 834, 8023, 969, + 787, 8040, 969, 788, 8041, 8032, 768, 8042, + 8033, 768, 8043, 8032, 769, 8044, 8033, 769, + 8045, 8032, 834, 8046, 8033, 834, 8047, 937, + 787, 8032, 937, 788, 8033, 8040, 768, 8034, + 8041, 768, 8035, 8040, 769, 8036, 8041, 769, + 8037, 8040, 834, 8038, 8041, 834, 8039, 945, + 768, 8122, 8123, 949, 768, 8136, 8137, 951, + 768, 8138, 8139, 953, 768, 8154, 8155, 959, + 768, 8184, 8185, 965, 768, 8170, 8171, 969, + 768, 8186, 8187, 7936, 837, 7936, 953, 8072, + 7937, 837, 7937, 953, 8073, 7938, 837, 7938, + 953, 8074, 7939, 837, 7939, 953, 8075, 7940, + 837, 7940, 953, 8076, 7941, 837, 7941, 953, + 8077, 7942, 837, 7942, 953, 8078, 7943, 837, + 7943, 953, 8079, 7944, 837, 8064, 7945, 837, + 8065, 7946, 837, 8066, 7947, 837, 8067, 7948, + 837, 8068, 7949, 837, 8069, 7950, 837, 8070, + 7951, 837, 8071, 7968, 837, 7968, 953, 8088, + 7969, 837, 7969, 953, 8089, 7970, 837, 7970, + 953, 8090, 7971, 837, 7971, 953, 8091, 7972, + 837, 7972, 953, 8092, 7973, 837, 7973, 953, + 8093, 7974, 837, 7974, 953, 8094, 7975, 837, + 7975, 953, 8095, 7976, 837, 8080, 7977, 837, + 8081, 7978, 837, 8082, 7979, 837, 8083, 7980, + 837, 8084, 7981, 837, 8085, 7982, 837, 8086, + 7983, 837, 8087, 8032, 837, 8032, 953, 8104, + 8033, 837, 8033, 953, 8105, 8034, 837, 8034, + 953, 8106, 8035, 837, 8035, 953, 8107, 8036, + 837, 8036, 953, 8108, 8037, 837, 8037, 953, + 8109, 8038, 837, 8038, 953, 8110, 8039, 837, + 8039, 953, 8111, 8040, 837, 8096, 8041, 837, + 8097, 8042, 837, 8098, 8043, 837, 8099, 8044, + 837, 8100, 8045, 837, 8101, 8046, 837, 8102, + 8047, 837, 8103, 945, 774, 8120, 945, 772, + 8121, 8048, 837, 8048, 953, 8114, 945, 837, + 945, 953, 8124, 940, 837, 940, 953, 8116, + 945, 834, 8118, 8118, 837, 945, 834, 953, + 8119, 913, 774, 8112, 913, 772, 8113, 913, + 768, 8048, 8049, 913, 837, 8115, 32, 787, + 32, 834, 168, 834, 8052, 837, 8052, 953, + 8130, 951, 837, 951, 953, 8140, 942, 837, + 942, 953, 8132, 951, 834, 8134, 8134, 837, + 951, 834, 953, 8135, 917, 768, 8050, 8051, + 919, 768, 8052, 8053, 919, 837, 8131, 8127, + 768, 8127, 769, 8127, 834, 953, 774, 8152, + 953, 772, 8153, 970, 768, 953, 776, 768, + 8146, 8147, 953, 834, 8150, 970, 834, 953, + 776, 834, 8151, 921, 774, 8144, 921, 772, + 8145, 921, 768, 8054, 8055, 8190, 768, 8190, + 769, 8190, 834, 965, 774, 8168, 965, 772, + 8169, 971, 768, 965, 776, 768, 8162, 8163, + 961, 787, 8164, 961, 788, 8172, 965, 834, + 8166, 971, 834, 965, 776, 834, 8167, 933, + 774, 8160, 933, 772, 8161, 933, 768, 8058, + 8059, 929, 788, 8165, 168, 768, 901, 96, + 8060, 837, 8060, 953, 8178, 969, 837, 969, + 953, 8188, 974, 837, 974, 953, 8180, 969, + 834, 8182, 8182, 837, 969, 834, 953, 8183, + 927, 768, 8056, 8057, 937, 768, 8060, 8061, + 937, 837, 8179, 180, 32, 788, 8194, 8195, 8208, 32, 819, 46, 46, 46, 46, 46, 46, 8242, 8242, 8242, 8242, 8242, 8245, 8245, 8245, 8245, 8245, 33, 33, 32, 773, 63, - 63, 63, 33, 33, 63, 8242, 8242, 8242, - 8242, 48, 52, 53, 54, 55, 56, 57, - 43, 8722, 61, 40, 41, 82, 115, 97, - 47, 99, 97, 47, 115, 67, 176, 67, - 99, 47, 111, 99, 47, 117, 400, 176, - 70, 78, 111, 81, 83, 77, 84, 69, - 76, 84, 77, 90, 937, 197, 70, 8526, - 1488, 1489, 1490, 1491, 70, 65, 88, 915, - 928, 8721, 49, 8260, 55, 49, 8260, 57, - 49, 8260, 49, 48, 49, 8260, 51, 50, - 8260, 51, 49, 8260, 53, 50, 8260, 53, - 51, 8260, 53, 52, 8260, 53, 49, 8260, - 54, 53, 8260, 54, 49, 8260, 56, 51, - 8260, 56, 53, 8260, 56, 55, 8260, 56, - 49, 8260, 8560, 73, 73, 8561, 73, 73, - 73, 8562, 73, 86, 8563, 86, 8564, 86, - 73, 8565, 86, 73, 73, 8566, 86, 73, - 73, 73, 8567, 73, 88, 8568, 88, 8569, - 88, 73, 8570, 88, 73, 73, 8571, 8572, - 8573, 8574, 8575, 105, 105, 105, 105, 105, - 105, 118, 118, 105, 118, 105, 105, 118, - 105, 105, 105, 105, 120, 120, 105, 120, - 105, 105, 8580, 48, 8260, 51, 8592, 824, - 8594, 824, 8596, 824, 8656, 824, 8660, 824, - 8658, 824, 8707, 824, 8712, 824, 8715, 824, - 8739, 824, 8741, 824, 8747, 8747, 8747, 8747, - 8747, 8750, 8750, 8750, 8750, 8750, 8764, 824, - 8771, 824, 8773, 824, 8776, 824, 61, 824, - 8801, 824, 8781, 824, 60, 824, 62, 824, - 8804, 824, 8805, 824, 8818, 824, 8819, 824, - 8822, 824, 8823, 824, 8826, 824, 8827, 824, - 8834, 824, 8835, 824, 8838, 824, 8839, 824, - 8866, 824, 8872, 824, 8873, 824, 8875, 824, - 8828, 824, 8829, 824, 8849, 824, 8850, 824, - 8882, 824, 8883, 824, 8884, 824, 8885, 824, - 12296, 12297, 49, 48, 49, 49, 49, 50, - 49, 51, 49, 52, 49, 53, 49, 54, - 49, 55, 49, 56, 49, 57, 50, 48, - 40, 49, 41, 40, 50, 41, 40, 51, - 41, 40, 52, 41, 40, 53, 41, 40, - 54, 41, 40, 55, 41, 40, 56, 41, - 40, 57, 41, 40, 49, 48, 41, 40, - 49, 49, 41, 40, 49, 50, 41, 40, - 49, 51, 41, 40, 49, 52, 41, 40, - 49, 53, 41, 40, 49, 54, 41, 40, - 49, 55, 41, 40, 49, 56, 41, 40, - 49, 57, 41, 40, 50, 48, 41, 49, - 46, 50, 46, 51, 46, 52, 46, 53, - 46, 54, 46, 55, 46, 56, 46, 57, - 46, 49, 48, 46, 49, 49, 46, 49, - 50, 46, 49, 51, 46, 49, 52, 46, - 49, 53, 46, 49, 54, 46, 49, 55, - 46, 49, 56, 46, 49, 57, 46, 50, - 48, 46, 40, 97, 41, 40, 98, 41, - 40, 99, 41, 40, 100, 41, 40, 101, - 41, 40, 102, 41, 40, 103, 41, 40, - 104, 41, 40, 105, 41, 40, 106, 41, - 40, 107, 41, 40, 108, 41, 40, 109, - 41, 40, 110, 41, 40, 111, 41, 40, - 112, 41, 40, 113, 41, 40, 114, 41, - 40, 115, 41, 40, 116, 41, 40, 117, - 41, 40, 118, 41, 40, 119, 41, 40, - 120, 41, 40, 121, 41, 40, 122, 41, - 9424, 9425, 9426, 9427, 9428, 9429, 9430, 9431, - 9432, 9433, 9434, 9435, 9436, 9437, 9438, 9439, - 9440, 9441, 83, 9442, 9443, 9444, 9445, 9446, - 9447, 89, 9448, 9449, 8747, 8747, 8747, 8747, - 58, 58, 61, 61, 61, 61, 61, 61, - 10973, 824, 11312, 11313, 11314, 11315, 11316, 11317, - 11318, 11319, 11320, 11321, 11322, 11323, 11324, 11325, - 11326, 11327, 11328, 11329, 11330, 11331, 11332, 11333, - 11334, 11335, 11336, 11337, 11338, 11339, 11340, 11341, - 11342, 11343, 11344, 11345, 11346, 11347, 11348, 11349, - 11350, 11351, 11352, 11353, 11354, 11355, 11356, 11357, - 11358, 11361, 619, 7549, 637, 11368, 11370, 11372, - 11379, 11382, 575, 576, 11393, 11395, 11397, 11399, - 11401, 11403, 11405, 11407, 11409, 11411, 11413, 11415, - 11417, 11419, 11421, 11423, 11425, 11427, 11429, 11431, - 11433, 11435, 11437, 11439, 11441, 11443, 11445, 11447, - 11449, 11451, 11453, 11455, 11457, 11459, 11461, 11463, - 11465, 11467, 11469, 11471, 11473, 11475, 11477, 11479, - 11481, 11483, 11485, 11487, 11489, 11491, 11500, 11502, - 11507, 11617, 27597, 40863, 19968, 20008, 20022, 20031, - 20057, 20101, 20108, 20128, 20154, 20799, 20837, 20843, - 20866, 20886, 20907, 20960, 20981, 20992, 21147, 21241, - 21269, 21274, 21304, 21313, 21340, 21353, 21378, 21430, - 21448, 21475, 22231, 22303, 22763, 22786, 22794, 22805, - 22823, 22899, 23376, 23424, 23544, 23567, 23586, 23608, - 23662, 23665, 24027, 24037, 24049, 24062, 24178, 24186, - 24191, 24308, 24318, 24331, 24339, 24400, 24417, 24435, - 24515, 25096, 25142, 25163, 25903, 25908, 25991, 26007, - 26020, 26041, 26080, 26085, 26352, 26376, 26408, 27424, - 27490, 27513, 27571, 27595, 27604, 27611, 27663, 27668, - 27700, 28779, 29226, 29238, 29243, 29247, 29255, 29273, - 29275, 29356, 29572, 29577, 29916, 29926, 29976, 29983, - 29992, 30000, 30091, 30098, 30326, 30333, 30382, 30399, - 30446, 30683, 30690, 30707, 31034, 31160, 31166, 31348, - 31435, 31481, 31859, 31992, 32566, 32593, 32650, 32701, - 32769, 32780, 32786, 32819, 32895, 32905, 33251, 33258, - 33267, 33276, 33292, 33307, 33311, 33390, 33394, 33400, - 34381, 34411, 34880, 34892, 34915, 35198, 35211, 35282, - 35328, 35895, 35910, 35925, 35960, 35997, 36196, 36208, - 36275, 36523, 36554, 36763, 36784, 36789, 37009, 37193, - 37318, 37324, 37329, 38263, 38272, 38428, 38582, 38585, - 38632, 38737, 38750, 38754, 38761, 38859, 38893, 38899, - 38913, 39080, 39131, 39135, 39318, 39321, 39340, 39592, - 39640, 39647, 39717, 39727, 39730, 39740, 39770, 40165, - 40565, 40575, 40613, 40635, 40643, 40653, 40657, 40697, - 40701, 40718, 40723, 40736, 40763, 40778, 40786, 40845, - 40860, 40864, 12306, 21316, 21317, 12363, 12441, 12365, - 12441, 12367, 12441, 12369, 12441, 12371, 12441, 12373, - 12441, 12375, 12441, 12377, 12441, 12379, 12441, 12381, - 12441, 12383, 12441, 12385, 12441, 12388, 12441, 12390, - 12441, 12392, 12441, 12399, 12441, 12399, 12442, 12402, - 12441, 12402, 12442, 12405, 12441, 12405, 12442, 12408, - 12441, 12408, 12442, 12411, 12441, 12411, 12442, 12358, - 12441, 32, 12441, 32, 12442, 12445, 12441, 12424, - 12426, 12459, 12441, 12461, 12441, 12463, 12441, 12465, - 12441, 12467, 12441, 12469, 12441, 12471, 12441, 12473, - 12441, 12475, 12441, 12477, 12441, 12479, 12441, 12481, - 12441, 12484, 12441, 12486, 12441, 12488, 12441, 12495, - 12441, 12495, 12442, 12498, 12441, 12498, 12442, 12501, - 12441, 12501, 12442, 12504, 12441, 12504, 12442, 12507, - 12441, 12507, 12442, 12454, 12441, 12527, 12441, 12528, - 12441, 12529, 12441, 12530, 12441, 12541, 12441, 12467, - 12488, 4352, 4353, 4522, 4354, 4524, 4525, 4355, - 4356, 4357, 4528, 4529, 4530, 4531, 4532, 4533, - 4378, 4358, 4359, 4360, 4385, 4361, 4362, 4363, - 4364, 4365, 4366, 4367, 4368, 4369, 4370, 4449, - 4450, 4451, 4452, 4453, 4454, 4455, 4456, 4457, - 4458, 4459, 4460, 4461, 4462, 4463, 4464, 4465, - 4466, 4467, 4468, 4469, 4448, 4372, 4373, 4551, - 4552, 4556, 4558, 4563, 4567, 4569, 4380, 4573, - 4575, 4381, 4382, 4384, 4386, 4387, 4391, 4393, - 4395, 4396, 4397, 4398, 4399, 4402, 4406, 4416, - 4423, 4428, 4593, 4594, 4439, 4440, 4441, 4484, - 4485, 4488, 4497, 4498, 4500, 4510, 4513, 19977, - 22235, 19978, 20013, 19979, 30002, 19993, 19969, 22825, - 22320, 40, 4352, 41, 40, 4354, 41, 40, - 4355, 41, 40, 4357, 41, 40, 4358, 41, - 40, 4359, 41, 40, 4361, 41, 40, 4363, - 41, 40, 4364, 41, 40, 4366, 41, 40, - 4367, 41, 40, 4368, 41, 40, 4369, 41, - 40, 4370, 41, 40, 4352, 4449, 41, 40, - 4354, 4449, 41, 40, 4355, 4449, 41, 40, - 4357, 4449, 41, 40, 4358, 4449, 41, 40, - 4359, 4449, 41, 40, 4361, 4449, 41, 40, - 4363, 4449, 41, 40, 4364, 4449, 41, 40, - 4366, 4449, 41, 40, 4367, 4449, 41, 40, - 4368, 4449, 41, 40, 4369, 4449, 41, 40, - 4370, 4449, 41, 40, 4364, 4462, 41, 40, - 4363, 4457, 4364, 4453, 4523, 41, 40, 4363, - 4457, 4370, 4462, 41, 40, 19968, 41, 40, - 20108, 41, 40, 19977, 41, 40, 22235, 41, - 40, 20116, 41, 40, 20845, 41, 40, 19971, - 41, 40, 20843, 41, 40, 20061, 41, 40, - 21313, 41, 40, 26376, 41, 40, 28779, 41, - 40, 27700, 41, 40, 26408, 41, 40, 37329, - 41, 40, 22303, 41, 40, 26085, 41, 40, - 26666, 41, 40, 26377, 41, 40, 31038, 41, - 40, 21517, 41, 40, 29305, 41, 40, 36001, - 41, 40, 31069, 41, 40, 21172, 41, 40, - 20195, 41, 40, 21628, 41, 40, 23398, 41, - 40, 30435, 41, 40, 20225, 41, 40, 36039, - 41, 40, 21332, 41, 40, 31085, 41, 40, - 20241, 41, 40, 33258, 41, 40, 33267, 41, - 21839, 24188, 31631, 80, 84, 69, 50, 49, - 50, 50, 50, 51, 50, 52, 50, 53, - 50, 54, 50, 55, 50, 56, 50, 57, - 51, 48, 51, 49, 51, 50, 51, 51, - 51, 52, 51, 53, 4352, 4449, 4354, 4449, - 4355, 4449, 4357, 4449, 4358, 4449, 4359, 4449, - 4361, 4449, 4363, 4449, 4364, 4449, 4366, 4449, - 4367, 4449, 4368, 4449, 4369, 4449, 4370, 4449, - 4366, 4449, 4535, 4352, 4457, 4364, 4462, 4363, - 4468, 4363, 4462, 20116, 20845, 19971, 20061, 26666, - 26377, 31038, 21517, 29305, 36001, 31069, 21172, 31192, - 30007, 36969, 20778, 21360, 27880, 38917, 20241, 20889, - 27491, 24038, 21491, 21307, 23447, 23398, 30435, 20225, - 36039, 21332, 22812, 51, 54, 51, 55, 51, - 56, 51, 57, 52, 48, 52, 49, 52, - 50, 52, 51, 52, 52, 52, 53, 52, - 54, 52, 55, 52, 56, 52, 57, 53, - 48, 49, 26376, 50, 26376, 51, 26376, 52, - 26376, 53, 26376, 54, 26376, 55, 26376, 56, - 26376, 57, 26376, 49, 48, 26376, 49, 49, - 26376, 49, 50, 26376, 72, 103, 101, 114, - 103, 101, 86, 76, 84, 68, 12450, 12452, - 12454, 12456, 12458, 12459, 12461, 12463, 12465, 12467, - 12469, 12471, 12473, 12475, 12477, 12479, 12481, 12484, - 12486, 12488, 12490, 12491, 12492, 12493, 12494, 12495, - 12498, 12501, 12504, 12507, 12510, 12511, 12512, 12513, - 12514, 12516, 12518, 12520, 12521, 12522, 12523, 12524, - 12525, 12527, 12528, 12529, 12530, 20196, 21644, 12450, - 12497, 12540, 12488, 12450, 12523, 12501, 12449, 12450, - 12531, 12506, 12450, 12450, 12540, 12523, 12452, 12491, - 12531, 12464, 12452, 12531, 12481, 12454, 12457, 12531, - 12456, 12473, 12463, 12540, 12489, 12456, 12540, 12459, - 12540, 12458, 12531, 12473, 12458, 12540, 12512, 12459, - 12452, 12522, 12459, 12521, 12483, 12488, 12459, 12525, - 12522, 12540, 12460, 12525, 12531, 12460, 12531, 12510, - 12462, 12460, 12462, 12491, 12540, 12461, 12517, 12522, - 12540, 12462, 12523, 12480, 12540, 12461, 12525, 12461, - 12525, 12464, 12521, 12512, 12461, 12525, 12513, 12540, - 12488, 12523, 12461, 12525, 12527, 12483, 12488, 12464, - 12521, 12512, 12464, 12521, 12512, 12488, 12531, 12463, - 12523, 12476, 12452, 12525, 12463, 12525, 12540, 12493, - 12465, 12540, 12473, 12467, 12523, 12490, 12467, 12540, - 12509, 12469, 12452, 12463, 12523, 12469, 12531, 12481, - 12540, 12512, 12471, 12522, 12531, 12464, 12475, 12531, - 12481, 12475, 12531, 12488, 12480, 12540, 12473, 12487, - 12471, 12489, 12523, 12488, 12531, 12490, 12494, 12494, - 12483, 12488, 12495, 12452, 12484, 12497, 12540, 12475, - 12531, 12488, 12497, 12540, 12484, 12496, 12540, 12524, - 12523, 12500, 12450, 12473, 12488, 12523, 12500, 12463, - 12523, 12500, 12467, 12499, 12523, 12501, 12449, 12521, - 12483, 12489, 12501, 12451, 12540, 12488, 12502, 12483, - 12471, 12455, 12523, 12501, 12521, 12531, 12504, 12463, + 63, 63, 33, 33, 63, 3, 8242, 8242, + 8242, 8242, 48, 8305, 52, 53, 54, 55, + 56, 57, 43, 8722, 61, 40, 41, 8319, + 8336, 8337, 8338, 8339, 8340, 8341, 8342, 8343, + 8344, 8345, 8346, 8347, 8348, 82, 115, 97, + 47, 99, 97, 47, 115, 8450, 176, 67, + 99, 47, 111, 99, 47, 117, 8455, 176, + 70, 8458, 8459, 8460, 8461, 8462, 8463, 8464, + 8465, 8466, 8467, 8469, 78, 111, 8473, 8474, + 8475, 8476, 8477, 83, 77, 84, 69, 76, + 84, 77, 8484, 8488, 8492, 8493, 8495, 8496, + 8497, 8526, 8499, 8500, 1488, 1489, 1490, 1491, + 8505, 70, 65, 88, 8508, 8509, 8510, 8511, + 8721, 8517, 8518, 8519, 8520, 8521, 8498, 49, + 8260, 55, 49, 8260, 57, 3, 49, 8260, + 49, 48, 49, 8260, 51, 50, 8260, 51, + 49, 8260, 53, 50, 8260, 53, 51, 8260, + 53, 52, 8260, 53, 49, 8260, 54, 53, + 8260, 54, 49, 8260, 56, 51, 8260, 56, + 53, 8260, 56, 55, 8260, 56, 49, 8260, + 8560, 73, 73, 8561, 73, 73, 73, 8562, + 73, 86, 8563, 8564, 86, 73, 8565, 86, + 73, 73, 8566, 3, 86, 73, 73, 73, + 8567, 73, 88, 8568, 8569, 88, 73, 8570, + 88, 73, 73, 8571, 8572, 8573, 8574, 8575, + 8544, 105, 105, 8545, 105, 105, 105, 8546, + 105, 118, 8547, 8548, 118, 105, 8549, 118, + 105, 105, 8550, 3, 118, 105, 105, 105, + 8551, 105, 120, 8552, 8553, 120, 105, 8554, + 120, 105, 105, 8555, 8556, 8557, 8558, 8559, + 8580, 8579, 48, 8260, 51, 8592, 824, 8594, + 824, 8596, 824, 8656, 824, 8660, 824, 8658, + 824, 8707, 824, 8712, 824, 8715, 824, 8739, + 824, 8741, 824, 8747, 8747, 8747, 8747, 8747, + 8750, 8750, 8750, 8750, 8750, 8764, 824, 8771, + 824, 8773, 824, 8776, 824, 61, 824, 8801, + 824, 8781, 824, 60, 824, 62, 824, 8804, + 824, 8805, 824, 8818, 824, 8819, 824, 8822, + 824, 8823, 824, 8826, 824, 8827, 824, 8834, + 824, 8835, 824, 8838, 824, 8839, 824, 8866, + 824, 8872, 824, 8873, 824, 8875, 824, 8828, + 824, 8829, 824, 8849, 824, 8850, 824, 8882, + 824, 8883, 824, 8884, 824, 8885, 824, 12296, + 12297, 49, 48, 49, 49, 49, 50, 49, + 51, 49, 52, 49, 53, 49, 54, 49, + 55, 49, 56, 49, 57, 50, 48, 40, + 49, 41, 40, 50, 41, 40, 51, 41, + 40, 52, 41, 40, 53, 41, 40, 54, + 41, 40, 55, 41, 40, 56, 41, 40, + 57, 41, 3, 40, 49, 48, 41, 3, + 40, 49, 49, 41, 3, 40, 49, 50, + 41, 3, 40, 49, 51, 41, 3, 40, + 49, 52, 41, 3, 40, 49, 53, 41, + 3, 40, 49, 54, 41, 3, 40, 49, + 55, 41, 3, 40, 49, 56, 41, 3, + 40, 49, 57, 41, 3, 40, 50, 48, + 41, 49, 46, 50, 46, 51, 46, 52, + 46, 53, 46, 54, 46, 55, 46, 56, + 46, 57, 46, 49, 48, 46, 49, 49, + 46, 49, 50, 46, 49, 51, 46, 49, + 52, 46, 49, 53, 46, 49, 54, 46, + 49, 55, 46, 49, 56, 46, 49, 57, + 46, 50, 48, 46, 40, 97, 41, 40, + 98, 41, 40, 99, 41, 40, 100, 41, + 40, 101, 41, 40, 102, 41, 40, 103, + 41, 40, 104, 41, 40, 105, 41, 40, + 106, 41, 40, 107, 41, 40, 108, 41, + 40, 109, 41, 40, 110, 41, 40, 111, + 41, 40, 112, 41, 40, 113, 41, 40, + 114, 41, 40, 115, 41, 40, 116, 41, + 40, 117, 41, 40, 118, 41, 40, 119, + 41, 40, 120, 41, 40, 121, 41, 40, + 122, 41, 9424, 9425, 9426, 9427, 9428, 9429, + 9430, 9431, 9432, 9433, 9434, 9435, 9436, 9437, + 9438, 9439, 9440, 9441, 9442, 9443, 9444, 9445, + 9446, 9447, 9448, 9449, 9398, 9399, 9400, 9401, + 9402, 9403, 9404, 9405, 9406, 9407, 9408, 9409, + 9410, 9411, 9412, 9413, 9414, 9415, 9416, 9417, + 9418, 9419, 9420, 9421, 9422, 9423, 3, 8747, + 8747, 8747, 8747, 58, 58, 61, 61, 61, + 61, 61, 61, 10973, 824, 11312, 11313, 11314, + 11315, 11316, 11317, 11318, 11319, 11320, 11321, 11322, + 11323, 11324, 11325, 11326, 11327, 11328, 11329, 11330, + 11331, 11332, 11333, 11334, 11335, 11336, 11337, 11338, + 11339, 11340, 11341, 11342, 11343, 11344, 11345, 11346, + 11347, 11348, 11349, 11350, 11351, 11352, 11353, 11354, + 11355, 11356, 11357, 11358, 11359, 11264, 11265, 11266, + 11267, 11268, 11269, 11270, 11271, 11272, 11273, 11274, + 11275, 11276, 11277, 11278, 11279, 11280, 11281, 11282, + 11283, 11284, 11285, 11286, 11287, 11288, 11289, 11290, + 11291, 11292, 11293, 11294, 11295, 11296, 11297, 11298, + 11299, 11300, 11301, 11302, 11303, 11304, 11305, 11306, + 11307, 11308, 11309, 11310, 11311, 11361, 11360, 619, + 7549, 637, 570, 574, 11368, 11367, 11370, 11369, + 11372, 11371, 11377, 11379, 11378, 11380, 11382, 11381, + 11383, 11384, 11385, 11386, 11387, 11388, 11389, 575, + 576, 11393, 11392, 11395, 11394, 11397, 11396, 11399, + 11398, 11401, 11400, 11403, 11402, 11405, 11404, 11407, + 11406, 11409, 11408, 11411, 11410, 11413, 11412, 11415, + 11414, 11417, 11416, 11419, 11418, 11421, 11420, 11423, + 11422, 11425, 11424, 11427, 11426, 11429, 11428, 11431, + 11430, 11433, 11432, 11435, 11434, 11437, 11436, 11439, + 11438, 11441, 11440, 11443, 11442, 11445, 11444, 11447, + 11446, 11449, 11448, 11451, 11450, 11453, 11452, 11455, + 11454, 11457, 11456, 11459, 11458, 11461, 11460, 11463, + 11462, 11465, 11464, 11467, 11466, 11469, 11468, 11471, + 11470, 11473, 11472, 11475, 11474, 11477, 11476, 11479, + 11478, 11481, 11480, 11483, 11482, 11485, 11484, 11487, + 11486, 11489, 11488, 11491, 11490, 11492, 11500, 11499, + 11502, 11501, 11507, 11506, 4256, 4257, 4258, 4259, + 4260, 4261, 4262, 4263, 4264, 4265, 4266, 4267, + 4268, 4269, 4270, 4271, 4272, 4273, 4274, 4275, + 4276, 4277, 4278, 4279, 4280, 4281, 4282, 4283, + 4284, 4285, 4286, 4287, 4288, 4289, 4290, 4291, + 4292, 4293, 4295, 4301, 11617, 27597, 40863, 19968, + 20008, 20022, 20031, 20057, 20101, 20108, 20128, 20154, + 20799, 20837, 20843, 20866, 20886, 20907, 20960, 20981, + 20992, 21147, 21241, 21269, 21274, 21304, 21313, 21340, + 21353, 21378, 21430, 21448, 21475, 22231, 22303, 22763, + 22786, 22794, 22805, 22823, 22899, 23376, 23424, 23544, + 23567, 23586, 23608, 23662, 23665, 24027, 24037, 24049, + 24062, 24178, 24186, 24191, 24308, 24318, 24331, 24339, + 24400, 24417, 24435, 24515, 25096, 25142, 25163, 25903, + 25908, 25991, 26007, 26020, 26041, 26080, 26085, 26352, + 26376, 26408, 27424, 27490, 27513, 27571, 27595, 27604, + 27611, 27663, 27668, 27700, 28779, 29226, 29238, 29243, + 29247, 29255, 29273, 29275, 29356, 29572, 29577, 29916, + 29926, 29976, 29983, 29992, 30000, 30091, 30098, 30326, + 30333, 30382, 30399, 30446, 30683, 30690, 30707, 31034, + 31160, 31166, 31348, 31435, 31481, 31859, 31992, 32566, + 32593, 32650, 32701, 32769, 32780, 32786, 32819, 32895, + 32905, 33251, 33258, 33267, 33276, 33292, 33307, 33311, + 33390, 33394, 33400, 34381, 34411, 34880, 34892, 34915, + 35198, 35211, 35282, 35328, 35895, 35910, 35925, 35960, + 35997, 36196, 36208, 36275, 36523, 36554, 36763, 36784, + 36789, 37009, 37193, 37318, 37324, 37329, 38263, 38272, + 38428, 38582, 38585, 38632, 38737, 38750, 38754, 38761, + 38859, 38893, 38899, 38913, 39080, 39131, 39135, 39318, + 39321, 39340, 39592, 39640, 39647, 39717, 39727, 39730, + 39740, 39770, 40165, 40565, 40575, 40613, 40635, 40643, + 40653, 40657, 40697, 40701, 40718, 40723, 40736, 40763, + 40778, 40786, 40845, 40860, 40864, 12306, 21316, 21317, + 12363, 12441, 12365, 12441, 12367, 12441, 12369, 12441, + 12371, 12441, 12373, 12441, 12375, 12441, 12377, 12441, + 12379, 12441, 12381, 12441, 12383, 12441, 12385, 12441, + 12388, 12441, 12390, 12441, 12392, 12441, 12399, 12441, + 12399, 12442, 12402, 12441, 12402, 12442, 12405, 12441, + 12405, 12442, 12408, 12441, 12408, 12442, 12411, 12441, + 12411, 12442, 12358, 12441, 32, 12441, 32, 12442, + 12445, 12441, 12424, 12426, 12459, 12441, 12461, 12441, + 12463, 12441, 12465, 12441, 12467, 12441, 12469, 12441, + 12471, 12441, 12473, 12441, 12475, 12441, 12477, 12441, + 12479, 12441, 12481, 12441, 12484, 12441, 12486, 12441, + 12488, 12441, 12495, 12441, 12495, 12442, 12498, 12441, + 12498, 12442, 12501, 12441, 12501, 12442, 12504, 12441, + 12504, 12442, 12507, 12441, 12507, 12442, 12454, 12441, + 12527, 12441, 12528, 12441, 12529, 12441, 12530, 12441, + 12541, 12441, 12467, 12488, 4352, 4353, 4522, 4354, + 4524, 4525, 4355, 4356, 4357, 4528, 4529, 4530, + 4531, 4532, 4533, 4378, 4358, 4359, 4360, 4385, + 4361, 4362, 4363, 4364, 4365, 4366, 4367, 4368, + 4369, 4370, 4449, 4450, 4451, 4452, 4453, 4454, + 4455, 4456, 4457, 4458, 4459, 4460, 4461, 4462, + 4463, 4464, 4465, 4466, 4467, 4468, 4469, 4448, + 4372, 4373, 4551, 4552, 4556, 4558, 4563, 4567, + 4569, 4380, 4573, 4575, 4381, 4382, 4384, 4386, + 4387, 4391, 4393, 4395, 4396, 4397, 4398, 4399, + 4402, 4406, 4416, 4423, 4428, 4593, 4594, 4439, + 4440, 4441, 4484, 4485, 4488, 4497, 4498, 4500, + 4510, 4513, 19977, 22235, 19978, 20013, 19979, 30002, + 19993, 19969, 22825, 22320, 40, 4352, 41, 40, + 4354, 41, 40, 4355, 41, 40, 4357, 41, + 40, 4358, 41, 40, 4359, 41, 40, 4361, + 41, 40, 4363, 41, 40, 4364, 41, 40, + 4366, 41, 40, 4367, 41, 40, 4368, 41, + 40, 4369, 41, 40, 4370, 41, 3, 40, + 4352, 4449, 41, 3, 40, 4354, 4449, 41, + 3, 40, 4355, 4449, 41, 3, 40, 4357, + 4449, 41, 3, 40, 4358, 4449, 41, 3, + 40, 4359, 4449, 41, 3, 40, 4361, 4449, + 41, 3, 40, 4363, 4449, 41, 3, 40, + 4364, 4449, 41, 3, 40, 4366, 4449, 41, + 3, 40, 4367, 4449, 41, 3, 40, 4368, + 4449, 41, 3, 40, 4369, 4449, 41, 3, + 40, 4370, 4449, 41, 3, 40, 4364, 4462, + 41, 6, 40, 4363, 4457, 4364, 4453, 4523, + 41, 5, 40, 4363, 4457, 4370, 4462, 41, + 40, 19968, 41, 40, 20108, 41, 40, 19977, + 41, 40, 22235, 41, 40, 20116, 41, 40, + 20845, 41, 40, 19971, 41, 40, 20843, 41, + 40, 20061, 41, 40, 21313, 41, 40, 26376, + 41, 40, 28779, 41, 40, 27700, 41, 40, + 26408, 41, 40, 37329, 41, 40, 22303, 41, + 40, 26085, 41, 40, 26666, 41, 40, 26377, + 41, 40, 31038, 41, 40, 21517, 41, 40, + 29305, 41, 40, 36001, 41, 40, 31069, 41, + 40, 21172, 41, 40, 20195, 41, 40, 21628, + 41, 40, 23398, 41, 40, 30435, 41, 40, + 20225, 41, 40, 36039, 41, 40, 21332, 41, + 40, 31085, 41, 40, 20241, 41, 40, 33258, + 41, 40, 33267, 41, 21839, 24188, 31631, 80, + 84, 69, 50, 49, 50, 50, 50, 51, + 50, 52, 50, 53, 50, 54, 50, 55, + 50, 56, 50, 57, 51, 48, 51, 49, + 51, 50, 51, 51, 51, 52, 51, 53, + 4352, 4449, 4354, 4449, 4355, 4449, 4357, 4449, + 4358, 4449, 4359, 4449, 4361, 4449, 4363, 4449, + 4364, 4449, 4366, 4449, 4367, 4449, 4368, 4449, + 4369, 4449, 4370, 4449, 4, 4366, 4449, 4535, + 4352, 4457, 3, 4364, 4462, 4363, 4468, 4363, + 4462, 20116, 20845, 19971, 20061, 26666, 26377, 31038, + 21517, 29305, 36001, 31069, 21172, 31192, 30007, 36969, + 20778, 21360, 27880, 38917, 20241, 20889, 27491, 24038, + 21491, 21307, 23447, 23398, 30435, 20225, 36039, 21332, + 22812, 51, 54, 51, 55, 51, 56, 51, + 57, 52, 48, 52, 49, 52, 50, 52, + 51, 52, 52, 52, 53, 52, 54, 52, + 55, 52, 56, 52, 57, 53, 48, 49, + 26376, 50, 26376, 51, 26376, 52, 26376, 53, + 26376, 54, 26376, 55, 26376, 56, 26376, 57, + 26376, 49, 48, 26376, 49, 49, 26376, 49, + 50, 26376, 72, 103, 101, 114, 103, 101, + 86, 76, 84, 68, 12450, 12452, 12454, 12456, + 12458, 12459, 12461, 12463, 12465, 12467, 12469, 12471, + 12473, 12475, 12477, 12479, 12481, 12484, 12486, 12488, + 12490, 12491, 12492, 12493, 12494, 12495, 12498, 12501, + 12504, 12507, 12510, 12511, 12512, 12513, 12514, 12516, + 12518, 12520, 12521, 12522, 12523, 12524, 12525, 12527, + 12528, 12529, 12530, 20196, 21644, 3, 12450, 12497, + 12540, 12488, 3, 12450, 12523, 12501, 12449, 3, + 12450, 12531, 12506, 12450, 12450, 12540, 12523, 3, + 12452, 12491, 12531, 12464, 12452, 12531, 12481, 12454, + 12457, 12531, 4, 12456, 12473, 12463, 12540, 12489, + 3, 12456, 12540, 12459, 12540, 12458, 12531, 12473, + 12458, 12540, 12512, 12459, 12452, 12522, 3, 12459, + 12521, 12483, 12488, 3, 12459, 12525, 12522, 12540, + 12460, 12525, 12531, 12460, 12531, 12510, 12462, 12460, + 12462, 12491, 12540, 3, 12461, 12517, 12522, 12540, + 3, 12462, 12523, 12480, 12540, 12461, 12525, 4, + 12461, 12525, 12464, 12521, 12512, 5, 12461, 12525, + 12513, 12540, 12488, 12523, 4, 12461, 12525, 12527, + 12483, 12488, 12464, 12521, 12512, 4, 12464, 12521, + 12512, 12488, 12531, 4, 12463, 12523, 12476, 12452, + 12525, 3, 12463, 12525, 12540, 12493, 12465, 12540, + 12473, 12467, 12523, 12490, 12467, 12540, 12509, 3, + 12469, 12452, 12463, 12523, 4, 12469, 12531, 12481, + 12540, 12512, 3, 12471, 12522, 12531, 12464, 12475, + 12531, 12481, 12475, 12531, 12488, 12480, 12540, 12473, + 12487, 12471, 12489, 12523, 12488, 12531, 12490, 12494, + 12494, 12483, 12488, 12495, 12452, 12484, 4, 12497, + 12540, 12475, 12531, 12488, 12497, 12540, 12484, 3, + 12496, 12540, 12524, 12523, 4, 12500, 12450, 12473, + 12488, 12523, 12500, 12463, 12523, 12500, 12467, 12499, + 12523, 4, 12501, 12449, 12521, 12483, 12489, 3, + 12501, 12451, 12540, 12488, 4, 12502, 12483, 12471, + 12455, 12523, 12501, 12521, 12531, 4, 12504, 12463, 12479, 12540, 12523, 12506, 12477, 12506, 12491, 12498, 12504, 12523, 12484, 12506, 12531, 12473, 12506, 12540, - 12472, 12505, 12540, 12479, 12509, 12452, 12531, 12488, - 12508, 12523, 12488, 12507, 12531, 12509, 12531, 12489, - 12507, 12540, 12523, 12507, 12540, 12531, 12510, 12452, - 12463, 12525, 12510, 12452, 12523, 12510, 12483, 12495, - 12510, 12523, 12463, 12510, 12531, 12471, 12519, 12531, - 12511, 12463, 12525, 12531, 12511, 12522, 12511, 12522, - 12496, 12540, 12523, 12513, 12460, 12513, 12460, 12488, - 12531, 12513, 12540, 12488, 12523, 12516, 12540, 12489, - 12516, 12540, 12523, 12518, 12450, 12531, 12522, 12483, - 12488, 12523, 12522, 12521, 12523, 12500, 12540, 12523, - 12540, 12502, 12523, 12524, 12512, 12524, 12531, 12488, - 12466, 12531, 12527, 12483, 12488, 48, 28857, 49, - 28857, 50, 28857, 51, 28857, 52, 28857, 53, - 28857, 54, 28857, 55, 28857, 56, 28857, 57, - 28857, 49, 48, 28857, 49, 49, 28857, 49, - 50, 28857, 49, 51, 28857, 49, 52, 28857, - 49, 53, 28857, 49, 54, 28857, 49, 55, - 28857, 49, 56, 28857, 49, 57, 28857, 50, - 48, 28857, 50, 49, 28857, 50, 50, 28857, - 50, 51, 28857, 50, 52, 28857, 104, 80, - 97, 100, 97, 65, 85, 98, 97, 114, - 111, 86, 112, 99, 100, 109, 100, 109, - 178, 100, 109, 179, 73, 85, 24179, 25104, - 26157, 21644, 22823, 27491, 26126, 27835, 26666, 24335, - 20250, 31038, 112, 65, 110, 65, 956, 65, - 109, 65, 107, 65, 75, 66, 77, 66, - 71, 66, 99, 97, 108, 107, 99, 97, - 108, 112, 70, 110, 70, 956, 70, 956, - 103, 109, 103, 107, 103, 72, 122, 107, - 72, 122, 77, 72, 122, 71, 72, 122, - 84, 72, 122, 956, 8467, 109, 8467, 100, - 8467, 107, 8467, 102, 109, 110, 109, 956, - 109, 109, 109, 99, 109, 107, 109, 109, - 109, 178, 99, 109, 178, 109, 178, 107, - 109, 178, 109, 109, 179, 99, 109, 179, - 109, 179, 107, 109, 179, 109, 8725, 115, - 109, 8725, 115, 178, 80, 97, 107, 80, - 97, 77, 80, 97, 71, 80, 97, 114, - 97, 100, 114, 97, 100, 8725, 115, 114, - 97, 100, 8725, 115, 178, 112, 115, 110, - 115, 956, 115, 109, 115, 112, 86, 110, - 86, 956, 86, 109, 86, 107, 86, 77, - 86, 112, 87, 110, 87, 956, 87, 109, - 87, 107, 87, 77, 87, 107, 937, 77, - 937, 97, 46, 109, 46, 66, 113, 99, - 99, 99, 100, 67, 8725, 107, 103, 67, - 111, 46, 100, 66, 71, 121, 104, 97, - 72, 80, 105, 110, 75, 75, 75, 77, - 107, 116, 108, 109, 108, 110, 108, 111, - 103, 108, 120, 109, 98, 109, 105, 108, - 109, 111, 108, 80, 72, 112, 46, 109, - 46, 80, 80, 77, 80, 82, 115, 114, - 83, 118, 87, 98, 86, 8725, 109, 65, - 8725, 109, 49, 26085, 50, 26085, 51, 26085, - 52, 26085, 53, 26085, 54, 26085, 55, 26085, - 56, 26085, 57, 26085, 49, 48, 26085, 49, - 49, 26085, 49, 50, 26085, 49, 51, 26085, - 49, 52, 26085, 49, 53, 26085, 49, 54, - 26085, 49, 55, 26085, 49, 56, 26085, 49, - 57, 26085, 50, 48, 26085, 50, 49, 26085, - 50, 50, 26085, 50, 51, 26085, 50, 52, - 26085, 50, 53, 26085, 50, 54, 26085, 50, - 55, 26085, 50, 56, 26085, 50, 57, 26085, - 51, 48, 26085, 51, 49, 26085, 103, 97, - 108, 42561, 42563, 42565, 42567, 42569, 42573, 42575, - 42577, 42579, 42581, 42583, 42585, 42587, 42589, 42591, - 42593, 42595, 42597, 42599, 42601, 42603, 42605, 42625, - 42627, 42629, 42631, 42633, 42635, 42637, 42639, 42641, - 42643, 42645, 42647, 42649, 42651, 42787, 42789, 42791, - 42793, 42795, 42797, 42799, 42803, 42805, 42807, 42809, - 42811, 42813, 42815, 42817, 42819, 42821, 42823, 42825, - 42827, 42829, 42831, 42833, 42835, 42837, 42839, 42841, - 42843, 42845, 42847, 42849, 42851, 42853, 42855, 42857, - 42859, 42861, 42863, 42874, 42876, 7545, 42879, 42881, - 42883, 42885, 42887, 42892, 42897, 42899, 42903, 42905, - 42907, 42909, 42911, 42913, 42915, 42917, 42919, 42921, - 620, 670, 647, 43859, 42933, 42935, 42937, 42939, - 42941, 42943, 42947, 42900, 7566, 294, 43831, 43858, - 5024, 5025, 5026, 5027, 5028, 5029, 5030, 5031, - 5032, 5033, 5034, 5035, 5036, 5037, 5038, 5039, - 5040, 5041, 5042, 5043, 5044, 5045, 5046, 5047, - 5048, 5049, 5050, 5051, 5052, 5053, 5054, 5055, - 5056, 5057, 5058, 5059, 5060, 5061, 5062, 5063, - 5064, 5065, 5066, 5067, 5068, 5069, 5070, 5071, - 5072, 5073, 5074, 5075, 5076, 5077, 5078, 5079, - 5080, 5081, 5082, 5083, 5084, 5085, 5086, 5087, - 5088, 5089, 5090, 5091, 5092, 5093, 5094, 5095, - 5096, 5097, 5098, 5099, 5100, 5101, 5102, 5103, - 35912, 26356, 36040, 28369, 20018, 21477, 22865, 21895, - 22856, 25078, 30313, 32645, 34367, 34746, 35064, 37007, - 27138, 27931, 28889, 29662, 33853, 37226, 39409, 20098, - 21365, 27396, 29211, 34349, 40478, 23888, 28651, 34253, - 35172, 25289, 33240, 34847, 24266, 26391, 28010, 29436, - 37070, 20358, 20919, 21214, 25796, 27347, 29200, 30439, - 34310, 34396, 36335, 38706, 39791, 40442, 30860, 31103, - 32160, 33737, 37636, 35542, 22751, 24324, 31840, 32894, - 29282, 30922, 36034, 38647, 22744, 23650, 27155, 28122, - 28431, 32047, 32311, 38475, 21202, 32907, 20956, 20940, - 31260, 32190, 33777, 38517, 35712, 25295, 35582, 20025, - 23527, 24594, 29575, 30064, 21271, 30971, 20415, 24489, - 19981, 27852, 25976, 32034, 21443, 22622, 30465, 33865, - 35498, 27578, 27784, 25342, 33509, 25504, 30053, 20142, - 20841, 20937, 26753, 31975, 33391, 35538, 37327, 21237, - 21570, 24300, 26053, 28670, 31018, 38317, 39530, 40599, - 40654, 26310, 27511, 36706, 24180, 24976, 25088, 25754, - 28451, 29001, 29833, 31178, 32244, 32879, 36646, 34030, - 36899, 37706, 21015, 21155, 21693, 28872, 35010, 24265, - 24565, 25467, 27566, 31806, 29557, 20196, 22265, 23994, - 24604, 29618, 29801, 32666, 32838, 37428, 38646, 38728, - 38936, 20363, 31150, 37300, 38584, 24801, 20102, 20698, - 23534, 23615, 26009, 29134, 30274, 34044, 36988, 26248, - 38446, 21129, 26491, 26611, 27969, 28316, 29705, 30041, - 30827, 32016, 39006, 25134, 38520, 20523, 23833, 28138, - 36650, 24459, 24900, 26647, 38534, 21033, 21519, 23653, - 26131, 26446, 26792, 27877, 29702, 30178, 32633, 35023, - 35041, 38626, 21311, 28346, 21533, 29136, 29848, 34298, - 38563, 40023, 40607, 26519, 28107, 33256, 31520, 31890, - 29376, 28825, 35672, 20160, 33590, 21050, 20999, 24230, - 25299, 31958, 23429, 27934, 26292, 36667, 38477, 24275, - 20800, 21952, 22618, 26228, 20958, 29482, 30410, 31036, - 31070, 31077, 31119, 38742, 31934, 34322, 35576, 36920, - 37117, 39151, 39164, 39208, 40372, 37086, 38583, 20398, - 20711, 20813, 21193, 21220, 21329, 21917, 22022, 22120, - 22592, 22696, 23652, 24724, 24936, 24974, 25074, 25935, - 26082, 26257, 26757, 28023, 28186, 28450, 29038, 29227, - 29730, 30865, 31049, 31048, 31056, 31062, 31117, 31118, - 31296, 31361, 31680, 32265, 32321, 32626, 32773, 33261, - 33401, 33879, 35088, 35222, 35585, 35641, 36051, 36104, - 36790, 38627, 38911, 38971, 24693, 55376, 57070, 33304, - 20006, 20917, 20840, 20352, 20805, 20864, 21191, 21242, - 21845, 21913, 21986, 22707, 22852, 22868, 23138, 23336, - 24274, 24281, 24425, 24493, 24792, 24910, 24840, 24928, - 25140, 25540, 25628, 25682, 25942, 26395, 26454, 28379, - 28363, 28702, 30631, 29237, 29359, 29809, 29958, 30011, - 30237, 30239, 30427, 30452, 30538, 30528, 30924, 31409, - 31867, 32091, 32574, 33618, 33775, 34681, 35137, 35206, - 35519, 35531, 35565, 35722, 36664, 36978, 37273, 37494, - 38524, 38875, 38923, 39698, 55370, 56394, 55370, 56388, - 55372, 57301, 15261, 16408, 16441, 55380, 56905, 55383, - 56528, 55391, 57043, 40771, 40846, 102, 102, 102, - 105, 102, 108, 102, 102, 105, 102, 102, - 108, 383, 116, 115, 116, 1396, 1398, 1396, - 1381, 1396, 1387, 1406, 1398, 1396, 1389, 1497, + 12472, 12505, 12540, 12479, 3, 12509, 12452, 12531, + 12488, 12508, 12523, 12488, 12507, 12531, 12509, 12531, + 12489, 12507, 12540, 12523, 12507, 12540, 12531, 3, + 12510, 12452, 12463, 12525, 12510, 12452, 12523, 12510, + 12483, 12495, 12510, 12523, 12463, 4, 12510, 12531, + 12471, 12519, 12531, 3, 12511, 12463, 12525, 12531, + 12511, 12522, 4, 12511, 12522, 12496, 12540, 12523, + 12513, 12460, 3, 12513, 12460, 12488, 12531, 3, + 12513, 12540, 12488, 12523, 12516, 12540, 12489, 12516, + 12540, 12523, 12518, 12450, 12531, 3, 12522, 12483, + 12488, 12523, 12522, 12521, 12523, 12500, 12540, 3, + 12523, 12540, 12502, 12523, 12524, 12512, 4, 12524, + 12531, 12488, 12466, 12531, 12527, 12483, 12488, 48, + 28857, 49, 28857, 50, 28857, 51, 28857, 52, + 28857, 53, 28857, 54, 28857, 55, 28857, 56, + 28857, 57, 28857, 49, 48, 28857, 49, 49, + 28857, 49, 50, 28857, 49, 51, 28857, 49, + 52, 28857, 49, 53, 28857, 49, 54, 28857, + 49, 55, 28857, 49, 56, 28857, 49, 57, + 28857, 50, 48, 28857, 50, 49, 28857, 50, + 50, 28857, 50, 51, 28857, 50, 52, 28857, + 104, 80, 97, 100, 97, 65, 85, 98, + 97, 114, 111, 86, 112, 99, 100, 109, + 100, 109, 178, 100, 109, 179, 73, 85, + 24179, 25104, 26157, 21644, 22823, 27491, 26126, 27835, + 3, 26666, 24335, 20250, 31038, 112, 65, 110, + 65, 956, 65, 109, 65, 107, 65, 75, + 66, 77, 66, 71, 66, 99, 97, 108, + 3, 107, 99, 97, 108, 112, 70, 110, + 70, 956, 70, 956, 103, 109, 103, 107, + 103, 72, 122, 107, 72, 122, 77, 72, + 122, 71, 72, 122, 84, 72, 122, 956, + 8467, 109, 8467, 100, 8467, 107, 8467, 102, + 109, 110, 109, 956, 109, 109, 109, 99, + 109, 107, 109, 109, 109, 178, 99, 109, + 178, 109, 178, 107, 109, 178, 109, 109, + 179, 99, 109, 179, 109, 179, 107, 109, + 179, 109, 8725, 115, 3, 109, 8725, 115, + 178, 80, 97, 107, 80, 97, 77, 80, + 97, 71, 80, 97, 114, 97, 100, 4, + 114, 97, 100, 8725, 115, 5, 114, 97, + 100, 8725, 115, 178, 112, 115, 110, 115, + 956, 115, 109, 115, 112, 86, 110, 86, + 956, 86, 109, 86, 107, 86, 77, 86, + 112, 87, 110, 87, 956, 87, 109, 87, + 107, 87, 77, 87, 107, 937, 77, 937, + 3, 97, 46, 109, 46, 66, 113, 99, + 99, 99, 100, 3, 67, 8725, 107, 103, + 67, 111, 46, 100, 66, 71, 121, 104, + 97, 72, 80, 105, 110, 75, 75, 75, + 77, 107, 116, 108, 109, 108, 110, 108, + 111, 103, 108, 120, 109, 98, 109, 105, + 108, 109, 111, 108, 80, 72, 3, 112, + 46, 109, 46, 80, 80, 77, 80, 82, + 115, 114, 83, 118, 87, 98, 86, 8725, + 109, 65, 8725, 109, 49, 26085, 50, 26085, + 51, 26085, 52, 26085, 53, 26085, 54, 26085, + 55, 26085, 56, 26085, 57, 26085, 49, 48, + 26085, 49, 49, 26085, 49, 50, 26085, 49, + 51, 26085, 49, 52, 26085, 49, 53, 26085, + 49, 54, 26085, 49, 55, 26085, 49, 56, + 26085, 49, 57, 26085, 50, 48, 26085, 50, + 49, 26085, 50, 50, 26085, 50, 51, 26085, + 50, 52, 26085, 50, 53, 26085, 50, 54, + 26085, 50, 55, 26085, 50, 56, 26085, 50, + 57, 26085, 51, 48, 26085, 51, 49, 26085, + 103, 97, 108, 42561, 42560, 42563, 42562, 42565, + 42564, 42567, 42566, 42569, 42568, 42573, 42572, 42575, + 42574, 42577, 42576, 42579, 42578, 42581, 42580, 42583, + 42582, 42585, 42584, 42587, 42586, 42589, 42588, 42591, + 42590, 42593, 42592, 42595, 42594, 42597, 42596, 42599, + 42598, 42601, 42600, 42603, 42602, 42605, 42604, 42625, + 42624, 42627, 42626, 42629, 42628, 42631, 42630, 42633, + 42632, 42635, 42634, 42637, 42636, 42639, 42638, 42641, + 42640, 42643, 42642, 42645, 42644, 42647, 42646, 42649, + 42648, 42651, 42650, 42652, 42653, 42787, 42786, 42789, + 42788, 42791, 42790, 42793, 42792, 42795, 42794, 42797, + 42796, 42799, 42798, 42800, 42801, 42803, 42802, 42805, + 42804, 42807, 42806, 42809, 42808, 42811, 42810, 42813, + 42812, 42815, 42814, 42817, 42816, 42819, 42818, 42821, + 42820, 42823, 42822, 42825, 42824, 42827, 42826, 42829, + 42828, 42831, 42830, 42833, 42832, 42835, 42834, 42837, + 42836, 42839, 42838, 42841, 42840, 42843, 42842, 42845, + 42844, 42847, 42846, 42849, 42848, 42851, 42850, 42853, + 42852, 42855, 42854, 42857, 42856, 42859, 42858, 42861, + 42860, 42863, 42862, 42864, 42865, 42866, 42867, 42868, + 42869, 42870, 42871, 42872, 42874, 42873, 42876, 42875, + 7545, 42879, 42878, 42881, 42880, 42883, 42882, 42885, + 42884, 42887, 42886, 42892, 42891, 42894, 42897, 42896, + 42899, 42898, 42948, 42901, 42903, 42902, 42905, 42904, + 42907, 42906, 42909, 42908, 42911, 42910, 42913, 42912, + 42915, 42914, 42917, 42916, 42919, 42918, 42921, 42920, + 620, 42927, 670, 647, 43859, 42933, 42932, 42935, + 42934, 42937, 42936, 42939, 42938, 42941, 42940, 42943, + 42942, 42945, 42944, 42947, 42946, 42900, 7566, 42952, + 42951, 42954, 42953, 42961, 42960, 42963, 42965, 42967, + 42966, 42969, 42968, 42994, 42995, 42996, 42998, 42997, + 43000, 43001, 43002, 43824, 43825, 43826, 43827, 43828, + 43829, 43830, 43831, 43832, 43833, 43834, 43835, 43836, + 43837, 43838, 43839, 43840, 43841, 43842, 43843, 43844, + 43845, 43846, 43847, 43848, 43849, 43850, 43851, 43852, + 43853, 43854, 43855, 43856, 43857, 43858, 42931, 43860, + 43861, 43862, 43863, 43864, 43865, 43866, 43868, 43869, + 43870, 43871, 43872, 43873, 43874, 43875, 43876, 43877, + 43878, 43879, 43880, 43881, 5024, 5025, 5026, 5027, + 5028, 5029, 5030, 5031, 5032, 5033, 5034, 5035, + 5036, 5037, 5038, 5039, 5040, 5041, 5042, 5043, + 5044, 5045, 5046, 5047, 5048, 5049, 5050, 5051, + 5052, 5053, 5054, 5055, 5056, 5057, 5058, 5059, + 5060, 5061, 5062, 5063, 5064, 5065, 5066, 5067, + 5068, 5069, 5070, 5071, 5072, 5073, 5074, 5075, + 5076, 5077, 5078, 5079, 5080, 5081, 5082, 5083, + 5084, 5085, 5086, 5087, 5088, 5089, 5090, 5091, + 5092, 5093, 5094, 5095, 5096, 5097, 5098, 5099, + 5100, 5101, 5102, 5103, 35912, 26356, 36040, 28369, + 20018, 21477, 22865, 21895, 22856, 25078, 30313, 32645, + 34367, 34746, 35064, 37007, 27138, 27931, 28889, 29662, + 33853, 37226, 39409, 20098, 21365, 27396, 29211, 34349, + 40478, 23888, 28651, 34253, 35172, 25289, 33240, 34847, + 24266, 26391, 28010, 29436, 37070, 20358, 20919, 21214, + 25796, 27347, 29200, 30439, 34310, 34396, 36335, 38706, + 39791, 40442, 30860, 31103, 32160, 33737, 37636, 35542, + 22751, 24324, 31840, 32894, 29282, 30922, 36034, 38647, + 22744, 23650, 27155, 28122, 28431, 32047, 32311, 38475, + 21202, 32907, 20956, 20940, 31260, 32190, 33777, 38517, + 35712, 25295, 35582, 20025, 23527, 24594, 29575, 30064, + 21271, 30971, 20415, 24489, 19981, 27852, 25976, 32034, + 21443, 22622, 30465, 33865, 35498, 27578, 27784, 25342, + 33509, 25504, 30053, 20142, 20841, 20937, 26753, 31975, + 33391, 35538, 37327, 21237, 21570, 24300, 26053, 28670, + 31018, 38317, 39530, 40599, 40654, 26310, 27511, 36706, + 24180, 24976, 25088, 25754, 28451, 29001, 29833, 31178, + 32244, 32879, 36646, 34030, 36899, 37706, 21015, 21155, + 21693, 28872, 35010, 24265, 24565, 25467, 27566, 31806, + 29557, 20196, 22265, 23994, 24604, 29618, 29801, 32666, + 32838, 37428, 38646, 38728, 38936, 20363, 31150, 37300, + 38584, 24801, 20102, 20698, 23534, 23615, 26009, 29134, + 30274, 34044, 36988, 26248, 38446, 21129, 26491, 26611, + 27969, 28316, 29705, 30041, 30827, 32016, 39006, 25134, + 38520, 20523, 23833, 28138, 36650, 24459, 24900, 26647, + 38534, 21033, 21519, 23653, 26131, 26446, 26792, 27877, + 29702, 30178, 32633, 35023, 35041, 38626, 21311, 28346, + 21533, 29136, 29848, 34298, 38563, 40023, 40607, 26519, + 28107, 33256, 31520, 31890, 29376, 28825, 35672, 20160, + 33590, 21050, 20999, 24230, 25299, 31958, 23429, 27934, + 26292, 36667, 38477, 24275, 20800, 21952, 22618, 26228, + 20958, 29482, 30410, 31036, 31070, 31077, 31119, 38742, + 31934, 34322, 35576, 36920, 37117, 39151, 39164, 39208, + 40372, 37086, 38583, 20398, 20711, 20813, 21193, 21220, + 21329, 21917, 22022, 22120, 22592, 22696, 23652, 24724, + 24936, 24974, 25074, 25935, 26082, 26257, 26757, 28023, + 28186, 28450, 29038, 29227, 29730, 30865, 31049, 31048, + 31056, 31062, 31117, 31118, 31296, 31361, 31680, 32265, + 32321, 32626, 32773, 33261, 33401, 33879, 35088, 35222, + 35585, 35641, 36051, 36104, 36790, 38627, 38911, 38971, + 24693, 55376, 57070, 33304, 20006, 20917, 20840, 20352, + 20805, 20864, 21191, 21242, 21845, 21913, 21986, 22707, + 22852, 22868, 23138, 23336, 24274, 24281, 24425, 24493, + 24792, 24910, 24840, 24928, 25140, 25540, 25628, 25682, + 25942, 26395, 26454, 28379, 28363, 28702, 30631, 29237, + 29359, 29809, 29958, 30011, 30237, 30239, 30427, 30452, + 30538, 30528, 30924, 31409, 31867, 32091, 32574, 33618, + 33775, 34681, 35137, 35206, 35519, 35531, 35565, 35722, + 36664, 36978, 37273, 37494, 38524, 38875, 38923, 39698, + 55370, 56394, 55370, 56388, 55372, 57301, 15261, 16408, + 16441, 55380, 56905, 55383, 56528, 55391, 57043, 40771, + 40846, 102, 102, 64256, 102, 105, 64257, 102, + 108, 64258, 102, 102, 105, 64259, 102, 102, + 108, 64260, 383, 116, 115, 116, 64261, 64262, + 1396, 1398, 64275, 1396, 1381, 64276, 1396, 1387, + 64277, 1406, 1398, 64278, 1396, 1389, 64279, 1497, 1460, 1522, 1463, 1506, 1492, 1499, 1500, 1501, 1512, 1514, 1513, 1473, 1513, 1474, 64329, 1473, 64329, 1474, 1488, 1463, 1488, 1464, 1488, 1468, @@ -804,14 +1012,15 @@ static const utf8proc_uint16_t utf8proc_sequences[] = { 1581, 1610, 1581, 1580, 1610, 1605, 1580, 1610, 1601, 1605, 1610, 1576, 1581, 1610, 1587, 1582, 1610, 1606, 1580, 1610, 1589, 1604, 1746, 1602, - 1604, 1746, 1575, 1604, 1604, 1607, 1575, 1603, - 1576, 1585, 1605, 1581, 1605, 1583, 1589, 1604, - 1593, 1605, 1585, 1587, 1608, 1604, 1593, 1604, - 1610, 1607, 1608, 1587, 1604, 1605, 1589, 1604, - 1609, 17, 1589, 1604, 1609, 32, 1575, 1604, - 1604, 1607, 32, 1593, 1604, 1610, 1607, 32, - 1608, 1587, 1604, 1605, 7, 1580, 1604, 32, - 1580, 1604, 1575, 1604, 1607, 1585, 1740, 1575, + 1604, 1746, 3, 1575, 1604, 1604, 1607, 3, + 1575, 1603, 1576, 1585, 3, 1605, 1581, 1605, + 1583, 3, 1589, 1604, 1593, 1605, 3, 1585, + 1587, 1608, 1604, 3, 1593, 1604, 1610, 1607, + 3, 1608, 1587, 1604, 1605, 1589, 1604, 1609, + 17, 1589, 1604, 1609, 32, 1575, 1604, 1604, + 1607, 32, 1593, 1604, 1610, 1607, 32, 1608, + 1587, 1604, 1605, 7, 1580, 1604, 32, 1580, + 1604, 1575, 1604, 1607, 3, 1585, 1740, 1575, 1604, 44, 12289, 12290, 58, 33, 63, 12310, 12311, 8230, 8229, 8212, 8211, 95, 123, 125, 12308, 12309, 12304, 12305, 12298, 12299, 12300, 12301, @@ -829,326 +1038,31 @@ static const utf8proc_uint16_t utf8proc_sequences[] = { 47, 65345, 65346, 65347, 65348, 65349, 65350, 65351, 65352, 65353, 65354, 65355, 65356, 65357, 65358, 65359, 65360, 65361, 65362, 65363, 65364, 65365, 65366, 65367, - 65368, 65369, 65370, 94, 124, 126, 10629, 10630, - 12539, 12449, 12451, 12453, 12455, 12457, 12515, 12517, - 12519, 12483, 12540, 12531, 12441, 12442, 12644, 12593, - 12594, 12595, 12596, 12597, 12598, 12599, 12600, 12601, - 12602, 12603, 12604, 12605, 12606, 12607, 12608, 12609, - 12610, 12611, 12612, 12613, 12614, 12615, 12616, 12617, - 12618, 12619, 12620, 12621, 12622, 12623, 12624, 12625, - 12626, 12627, 12628, 12629, 12630, 12631, 12632, 12633, - 12634, 12635, 12636, 12637, 12638, 12639, 12640, 12641, - 12642, 12643, 162, 163, 172, 175, 166, 165, - 8361, 9474, 8592, 8593, 8594, 8595, 9632, 9675, - 55297, 56360, 55297, 56361, 55297, 56362, 55297, 56363, - 55297, 56364, 55297, 56365, 55297, 56366, 55297, 56367, - 55297, 56368, 55297, 56369, 55297, 56370, 55297, 56371, - 55297, 56372, 55297, 56373, 55297, 56374, 55297, 56375, - 55297, 56376, 55297, 56377, 55297, 56378, 55297, 56379, - 55297, 56380, 55297, 56381, 55297, 56382, 55297, 56383, - 55297, 56384, 55297, 56385, 55297, 56386, 55297, 56387, - 55297, 56388, 55297, 56389, 55297, 56390, 55297, 56391, - 55297, 56392, 55297, 56393, 55297, 56394, 55297, 56395, - 55297, 56396, 55297, 56397, 55297, 56398, 55297, 56399, - 55297, 56536, 55297, 56537, 55297, 56538, 55297, 56539, - 55297, 56540, 55297, 56541, 55297, 56542, 55297, 56543, - 55297, 56544, 55297, 56545, 55297, 56546, 55297, 56547, - 55297, 56548, 55297, 56549, 55297, 56550, 55297, 56551, - 55297, 56552, 55297, 56553, 55297, 56554, 55297, 56555, - 55297, 56556, 55297, 56557, 55297, 56558, 55297, 56559, - 55297, 56560, 55297, 56561, 55297, 56562, 55297, 56563, - 55297, 56564, 55297, 56565, 55297, 56566, 55297, 56567, - 55297, 56568, 55297, 56569, 55297, 56570, 55297, 56571, - 55299, 56512, 55299, 56513, 55299, 56514, 55299, 56515, - 55299, 56516, 55299, 56517, 55299, 56518, 55299, 56519, - 55299, 56520, 55299, 56521, 55299, 56522, 55299, 56523, - 55299, 56524, 55299, 56525, 55299, 56526, 55299, 56527, - 55299, 56528, 55299, 56529, 55299, 56530, 55299, 56531, - 55299, 56532, 55299, 56533, 55299, 56534, 55299, 56535, - 55299, 56536, 55299, 56537, 55299, 56538, 55299, 56539, - 55299, 56540, 55299, 56541, 55299, 56542, 55299, 56543, - 55299, 56544, 55299, 56545, 55299, 56546, 55299, 56547, - 55299, 56548, 55299, 56549, 55299, 56550, 55299, 56551, - 55299, 56552, 55299, 56553, 55299, 56554, 55299, 56555, - 55299, 56556, 55299, 56557, 55299, 56558, 55299, 56559, - 55299, 56560, 55299, 56561, 55299, 56562, 55300, 56473, - 55300, 56506, 55300, 56475, 55300, 56506, 55300, 56485, - 55300, 56506, 55300, 56625, 55300, 56615, 55300, 56626, - 55300, 56615, 55300, 57159, 55300, 57150, 55300, 57159, - 55300, 57175, 55301, 56505, 55301, 56506, 55301, 56505, - 55301, 56496, 55301, 56505, 55301, 56509, 55301, 56760, - 55301, 56751, 55301, 56761, 55301, 56751, 55302, 56512, - 55302, 56513, 55302, 56514, 55302, 56515, 55302, 56516, - 55302, 56517, 55302, 56518, 55302, 56519, 55302, 56520, - 55302, 56521, 55302, 56522, 55302, 56523, 55302, 56524, - 55302, 56525, 55302, 56526, 55302, 56527, 55302, 56528, - 55302, 56529, 55302, 56530, 55302, 56531, 55302, 56532, - 55302, 56533, 55302, 56534, 55302, 56535, 55302, 56536, - 55302, 56537, 55302, 56538, 55302, 56539, 55302, 56540, - 55302, 56541, 55302, 56542, 55302, 56543, 55323, 56928, - 55323, 56929, 55323, 56930, 55323, 56931, 55323, 56932, - 55323, 56933, 55323, 56934, 55323, 56935, 55323, 56936, - 55323, 56937, 55323, 56938, 55323, 56939, 55323, 56940, - 55323, 56941, 55323, 56942, 55323, 56943, 55323, 56944, - 55323, 56945, 55323, 56946, 55323, 56947, 55323, 56948, - 55323, 56949, 55323, 56950, 55323, 56951, 55323, 56952, - 55323, 56953, 55323, 56954, 55323, 56955, 55323, 56956, - 55323, 56957, 55323, 56958, 55323, 56959, 55348, 56663, - 55348, 56677, 55348, 56664, 55348, 56677, 55348, 56671, - 55348, 56686, 55348, 56671, 55348, 56687, 55348, 56671, - 55348, 56688, 55348, 56671, 55348, 56689, 55348, 56671, - 55348, 56690, 55348, 56761, 55348, 56677, 55348, 56762, - 55348, 56677, 55348, 56763, 55348, 56686, 55348, 56764, - 55348, 56686, 55348, 56763, 55348, 56687, 55348, 56764, - 55348, 56687, 305, 567, 913, 914, 916, 917, - 918, 919, 921, 922, 923, 924, 925, 926, - 927, 929, 1012, 932, 934, 935, 936, 8711, - 8706, 1013, 977, 1008, 981, 1009, 982, 988, - 55354, 56610, 55354, 56611, 55354, 56612, 55354, 56613, - 55354, 56614, 55354, 56615, 55354, 56616, 55354, 56617, - 55354, 56618, 55354, 56619, 55354, 56620, 55354, 56621, - 55354, 56622, 55354, 56623, 55354, 56624, 55354, 56625, - 55354, 56626, 55354, 56627, 55354, 56628, 55354, 56629, - 55354, 56630, 55354, 56631, 55354, 56632, 55354, 56633, - 55354, 56634, 55354, 56635, 55354, 56636, 55354, 56637, - 55354, 56638, 55354, 56639, 55354, 56640, 55354, 56641, - 55354, 56642, 55354, 56643, 1646, 1697, 1647, 48, - 46, 48, 44, 49, 44, 50, 44, 51, - 44, 52, 44, 53, 44, 54, 44, 55, - 44, 56, 44, 57, 44, 40, 65, 41, - 40, 66, 41, 40, 67, 41, 40, 68, - 41, 40, 69, 41, 40, 70, 41, 40, - 71, 41, 40, 72, 41, 40, 73, 41, - 40, 74, 41, 40, 75, 41, 40, 76, - 41, 40, 77, 41, 40, 78, 41, 40, - 79, 41, 40, 80, 41, 40, 81, 41, - 40, 82, 41, 40, 83, 41, 40, 84, - 41, 40, 85, 41, 40, 86, 41, 40, - 87, 41, 40, 88, 41, 40, 89, 41, - 40, 90, 41, 12308, 83, 12309, 67, 68, - 87, 90, 72, 86, 83, 68, 83, 83, - 80, 80, 86, 87, 67, 77, 67, 77, - 68, 77, 82, 68, 74, 12411, 12363, 12467, - 12467, 23383, 21452, 12487, 22810, 35299, 20132, 26144, - 28961, 21069, 24460, 20877, 26032, 21021, 32066, 36009, - 22768, 21561, 28436, 25237, 25429, 36938, 25351, 25171, - 31105, 31354, 21512, 28288, 30003, 21106, 21942, 37197, - 12308, 26412, 12309, 12308, 19977, 12309, 12308, 20108, - 12309, 12308, 23433, 12309, 12308, 28857, 12309, 12308, - 25171, 12309, 12308, 30423, 12309, 12308, 21213, 12309, - 12308, 25943, 12309, 24471, 21487, 20029, 20024, 20033, - 55360, 56610, 20320, 20411, 20482, 20602, 20633, 20687, - 13470, 55361, 56890, 20820, 20836, 20855, 55361, 56604, - 13497, 20839, 55361, 56651, 20887, 20900, 20172, 20908, - 55396, 56799, 20995, 13535, 21051, 21062, 21111, 13589, - 21253, 21254, 21321, 21338, 21363, 21373, 21375, 55362, - 56876, 28784, 21450, 21471, 55362, 57187, 21483, 21489, - 21510, 21662, 21560, 21576, 21608, 21666, 21750, 21776, - 21843, 21859, 21892, 21931, 21939, 21954, 22294, 22295, - 22097, 22132, 22766, 22478, 22516, 22541, 22411, 22578, - 22577, 22700, 55365, 56548, 22770, 22775, 22790, 22818, - 22882, 55365, 57000, 55365, 57066, 23020, 23067, 23079, - 23000, 23142, 14062, 14076, 23304, 23358, 55366, 56776, - 23491, 23512, 23539, 55366, 57112, 23551, 23558, 24403, - 14209, 23648, 23744, 23693, 55367, 56804, 23875, 55367, - 56806, 23918, 23915, 23932, 24033, 24034, 14383, 24061, - 24104, 24125, 24169, 14434, 55368, 56707, 14460, 24240, - 24243, 24246, 55400, 57234, 55368, 57137, 33281, 24354, - 14535, 55372, 57016, 55384, 56794, 24418, 24427, 14563, - 24474, 24525, 24535, 24569, 24705, 14650, 14620, 55369, - 57044, 24775, 24904, 24908, 24954, 25010, 24996, 25007, - 25054, 25104, 25115, 25181, 25265, 25300, 25424, 55370, - 57100, 25405, 25340, 25448, 25475, 25572, 55370, 57329, - 25634, 25541, 25513, 14894, 25705, 25726, 25757, 25719, - 14956, 25964, 55372, 56330, 26083, 26360, 26185, 15129, - 15112, 15076, 20882, 20885, 26368, 26268, 32941, 17369, - 26401, 26462, 26451, 55372, 57283, 15177, 26618, 26501, - 26706, 55373, 56429, 26766, 26655, 26900, 26946, 27043, - 27114, 27304, 55373, 56995, 27355, 15384, 27425, 55374, - 56487, 27476, 15438, 27506, 27551, 27579, 55374, 56973, - 55367, 56587, 55374, 57082, 27726, 55375, 56508, 27839, - 27853, 27751, 27926, 27966, 28009, 28024, 28037, 55375, - 56606, 27956, 28207, 28270, 15667, 28359, 55375, 57041, - 28153, 28526, 55375, 57182, 55375, 57230, 28614, 28729, - 28699, 15766, 28746, 28797, 28791, 28845, 55361, 56613, - 28997, 55376, 56931, 29084, 55376, 57259, 29224, 29264, - 55377, 56840, 29312, 29333, 55377, 57141, 55378, 56340, - 29562, 29579, 16044, 29605, 16056, 29767, 29788, 29829, - 29898, 16155, 29988, 55379, 56374, 30014, 55379, 56466, - 55368, 56735, 30224, 55379, 57249, 55379, 57272, 55380, - 56388, 16380, 16392, 55380, 56563, 55380, 56562, 55380, - 56601, 55380, 56627, 30494, 30495, 30603, 16454, 16534, - 55381, 56349, 30798, 16611, 55381, 56870, 55381, 56986, - 55381, 57029, 31211, 16687, 31306, 31311, 55382, 56700, - 55382, 56999, 31470, 16898, 55382, 57259, 31686, 31689, - 16935, 55383, 56448, 31954, 17056, 31976, 31971, 32000, - 55383, 57222, 32099, 17153, 32199, 32258, 32325, 17204, - 55384, 56872, 55384, 56903, 17241, 55384, 57049, 32634, - 55384, 57150, 32661, 32762, 55385, 56538, 55385, 56611, - 32864, 55385, 56744, 32880, 55372, 57183, 17365, 32946, - 33027, 17419, 33086, 23221, 55385, 57255, 55385, 57269, - 55372, 57235, 55372, 57244, 33284, 36766, 17515, 33425, - 33419, 33437, 21171, 33457, 33459, 33469, 33510, 55386, - 57148, 33565, 33635, 33709, 33571, 33725, 33767, 33619, - 33738, 33740, 33756, 55387, 56374, 55387, 56683, 55387, - 56533, 17707, 34033, 34035, 34070, 55388, 57290, 34148, - 55387, 57132, 17757, 17761, 55387, 57265, 55388, 56530, - 17771, 34384, 34407, 34409, 34473, 34440, 34574, 34530, - 34600, 34667, 34694, 17879, 34785, 34817, 17913, 34912, - 55389, 56935, 35031, 35038, 17973, 35066, 13499, 55390, - 56494, 55390, 56678, 18110, 18119, 35488, 55391, 56488, - 36011, 36033, 36123, 36215, 55391, 57135, 55362, 56324, - 36299, 36284, 36336, 55362, 56542, 36564, 55393, 56786, - 55393, 56813, 37012, 37105, 37137, 55393, 57134, 37147, - 37432, 37591, 37592, 37500, 37881, 37909, 55394, 57338, - 38283, 18837, 38327, 55395, 56695, 18918, 38595, 23986, - 38691, 55396, 56645, 55396, 56858, 19054, 19062, 38880, - 55397, 56330, 19122, 55397, 56470, 38953, 55397, 56758, - 39138, 19251, 39209, 39335, 39362, 39422, 19406, 55398, - 57136, 40000, 40189, 19662, 19693, 40295, 55400, 56526, - 19704, 55400, 56581, 55400, 56846, 55400, 56977, 19798, - 40702, 40709, 40719, 40726, 55401, 56832, 7838, 192, - 193, 194, 195, 196, 199, 200, 201, 202, - 203, 204, 205, 206, 207, 208, 209, 210, - 211, 212, 213, 214, 216, 217, 218, 219, - 220, 221, 222, 376, 256, 258, 260, 262, - 264, 266, 268, 270, 272, 274, 276, 278, - 280, 282, 284, 286, 288, 290, 292, 296, - 298, 300, 302, 306, 308, 310, 313, 315, - 317, 319, 321, 323, 325, 327, 330, 332, - 334, 336, 338, 340, 342, 344, 346, 348, - 350, 352, 354, 356, 358, 360, 362, 364, - 366, 368, 370, 372, 374, 377, 379, 381, - 579, 386, 388, 391, 395, 401, 502, 408, - 573, 544, 416, 418, 420, 423, 428, 431, - 435, 437, 440, 444, 503, 453, 452, 456, - 455, 459, 458, 461, 463, 465, 467, 469, - 471, 473, 475, 478, 480, 482, 484, 486, - 488, 490, 492, 494, 498, 497, 500, 504, - 506, 508, 510, 512, 514, 516, 518, 520, - 522, 524, 526, 528, 530, 532, 534, 536, - 538, 540, 542, 548, 550, 552, 554, 556, - 558, 560, 562, 571, 11390, 11391, 577, 582, - 584, 586, 588, 590, 11375, 11373, 11376, 385, - 390, 393, 394, 399, 42923, 403, 42924, 404, - 42893, 42922, 407, 406, 42926, 11362, 42925, 412, - 11374, 413, 415, 11364, 422, 42949, 425, 42929, - 430, 580, 433, 434, 581, 439, 42930, 42928, - 880, 882, 886, 1021, 1022, 1023, 938, 939, - 975, 984, 986, 990, 992, 994, 996, 998, - 1000, 1002, 1004, 1006, 1017, 895, 1015, 1018, - 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, - 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, - 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, - 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, - 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031, - 1032, 1033, 1034, 1035, 1036, 1037, 1038, 1039, - 1120, 1122, 1124, 1126, 1128, 1130, 1132, 1134, - 1136, 1138, 1140, 1142, 1144, 1146, 1148, 1150, - 1152, 1162, 1164, 1166, 1168, 1170, 1172, 1174, - 1176, 1178, 1180, 1182, 1184, 1186, 1188, 1190, - 1192, 1194, 1196, 1198, 1200, 1202, 1204, 1206, - 1208, 1210, 1212, 1214, 1217, 1219, 1221, 1223, - 1225, 1227, 1229, 1216, 1232, 1234, 1236, 1238, - 1240, 1242, 1244, 1246, 1248, 1250, 1252, 1254, - 1256, 1258, 1260, 1262, 1264, 1266, 1268, 1270, - 1272, 1274, 1276, 1278, 1280, 1282, 1284, 1286, - 1288, 1290, 1292, 1294, 1296, 1298, 1300, 1302, - 1304, 1306, 1308, 1310, 1312, 1314, 1316, 1318, - 1320, 1322, 1324, 1326, 1329, 1330, 1331, 1332, - 1333, 1334, 1335, 1336, 1337, 1338, 1339, 1340, - 1341, 1342, 1343, 1344, 1345, 1346, 1347, 1348, - 1349, 1350, 1351, 1352, 1353, 1354, 1355, 1356, - 1357, 1358, 1359, 1360, 1361, 1362, 1363, 1364, - 1365, 1366, 7312, 7313, 7314, 7315, 7316, 7317, - 7318, 7319, 7320, 7321, 7322, 7323, 7324, 7325, - 7326, 7327, 7328, 7329, 7330, 7331, 7332, 7333, - 7334, 7335, 7336, 7337, 7338, 7339, 7340, 7341, - 7342, 7343, 7344, 7345, 7346, 7347, 7348, 7349, - 7350, 7351, 7352, 7353, 7354, 7357, 7358, 7359, - 43888, 43889, 43890, 43891, 43892, 43893, 43894, 43895, - 43896, 43897, 43898, 43899, 43900, 43901, 43902, 43903, - 43904, 43905, 43906, 43907, 43908, 43909, 43910, 43911, - 43912, 43913, 43914, 43915, 43916, 43917, 43918, 43919, - 43920, 43921, 43922, 43923, 43924, 43925, 43926, 43927, - 43928, 43929, 43930, 43931, 43932, 43933, 43934, 43935, - 43936, 43937, 43938, 43939, 43940, 43941, 43942, 43943, - 43944, 43945, 43946, 43947, 43948, 43949, 43950, 43951, - 43952, 43953, 43954, 43955, 43956, 43957, 43958, 43959, - 43960, 43961, 43962, 43963, 43964, 43965, 43966, 43967, - 5112, 5113, 5114, 5115, 5116, 5117, 42570, 42877, - 11363, 42950, 7680, 7682, 7684, 7686, 7688, 7690, - 7692, 7694, 7696, 7698, 7700, 7702, 7704, 7706, - 7708, 7710, 7712, 7714, 7716, 7718, 7720, 7722, - 7724, 7726, 7728, 7730, 7732, 7734, 7736, 7738, - 7740, 7742, 7744, 7746, 7748, 7750, 7752, 7754, - 7756, 7758, 7760, 7762, 7764, 7766, 7768, 7770, - 7772, 7774, 7776, 7778, 7780, 7782, 7784, 7786, - 7788, 7790, 7792, 7794, 7796, 7798, 7800, 7802, - 7804, 7806, 7808, 7810, 7812, 7814, 7816, 7818, - 7820, 7822, 7824, 7826, 7828, 223, 7840, 7842, - 7844, 7846, 7848, 7850, 7852, 7854, 7856, 7858, - 7860, 7862, 7864, 7866, 7868, 7870, 7872, 7874, - 7876, 7878, 7880, 7882, 7884, 7886, 7888, 7890, - 7892, 7894, 7896, 7898, 7900, 7902, 7904, 7906, - 7908, 7910, 7912, 7914, 7916, 7918, 7920, 7922, - 7924, 7926, 7928, 7930, 7932, 7934, 7944, 7945, - 7946, 7947, 7948, 7949, 7950, 7951, 7960, 7961, - 7962, 7963, 7964, 7965, 7976, 7977, 7978, 7979, - 7980, 7981, 7982, 7983, 7992, 7993, 7994, 7995, - 7996, 7997, 7998, 7999, 8008, 8009, 8010, 8011, - 8012, 8013, 8025, 8027, 8029, 8031, 8040, 8041, - 8042, 8043, 8044, 8045, 8046, 8047, 8122, 8123, - 8136, 8137, 8138, 8139, 8154, 8155, 8184, 8185, - 8170, 8171, 8186, 8187, 8072, 8073, 8074, 8075, - 8076, 8077, 8078, 8079, 8064, 8065, 8066, 8067, - 8068, 8069, 8070, 8071, 8088, 8089, 8090, 8091, - 8092, 8093, 8094, 8095, 8080, 8081, 8082, 8083, - 8084, 8085, 8086, 8087, 8104, 8105, 8106, 8107, - 8108, 8109, 8110, 8111, 8096, 8097, 8098, 8099, - 8100, 8101, 8102, 8103, 8120, 8121, 8124, 8115, - 8140, 8131, 8152, 8153, 8168, 8169, 8172, 8188, - 8179, 8498, 8544, 8545, 8546, 8547, 8548, 8549, - 8550, 8551, 8552, 8553, 8554, 8555, 8556, 8557, - 8558, 8559, 8579, 9398, 9399, 9400, 9401, 9402, - 9403, 9404, 9405, 9406, 9407, 9408, 9409, 9410, - 9411, 9412, 9413, 9414, 9415, 9416, 9417, 9418, - 9419, 9420, 9421, 9422, 9423, 11264, 11265, 11266, - 11267, 11268, 11269, 11270, 11271, 11272, 11273, 11274, - 11275, 11276, 11277, 11278, 11279, 11280, 11281, 11282, - 11283, 11284, 11285, 11286, 11287, 11288, 11289, 11290, - 11291, 11292, 11293, 11294, 11295, 11296, 11297, 11298, - 11299, 11300, 11301, 11302, 11303, 11304, 11305, 11306, - 11307, 11308, 11309, 11310, 11360, 570, 574, 11367, - 11369, 11371, 11378, 11381, 11392, 11394, 11396, 11398, - 11400, 11402, 11404, 11406, 11408, 11410, 11412, 11414, - 11416, 11418, 11420, 11422, 11424, 11426, 11428, 11430, - 11432, 11434, 11436, 11438, 11440, 11442, 11444, 11446, - 11448, 11450, 11452, 11454, 11456, 11458, 11460, 11462, - 11464, 11466, 11468, 11470, 11472, 11474, 11476, 11478, - 11480, 11482, 11484, 11486, 11488, 11490, 11499, 11501, - 11506, 4256, 4257, 4258, 4259, 4260, 4261, 4262, - 4263, 4264, 4265, 4266, 4267, 4268, 4269, 4270, - 4271, 4272, 4273, 4274, 4275, 4276, 4277, 4278, - 4279, 4280, 4281, 4282, 4283, 4284, 4285, 4286, - 4287, 4288, 4289, 4290, 4291, 4292, 4293, 4295, - 4301, 42560, 42562, 42564, 42566, 42568, 42572, 42574, - 42576, 42578, 42580, 42582, 42584, 42586, 42588, 42590, - 42592, 42594, 42596, 42598, 42600, 42602, 42604, 42624, - 42626, 42628, 42630, 42632, 42634, 42636, 42638, 42640, - 42642, 42644, 42646, 42648, 42650, 42786, 42788, 42790, - 42792, 42794, 42796, 42798, 42802, 42804, 42806, 42808, - 42810, 42812, 42814, 42816, 42818, 42820, 42822, 42824, - 42826, 42828, 42830, 42832, 42834, 42836, 42838, 42840, - 42842, 42844, 42846, 42848, 42850, 42852, 42854, 42856, - 42858, 42860, 42862, 42873, 42875, 42878, 42880, 42882, - 42884, 42886, 42891, 42896, 42898, 42948, 42902, 42904, - 42906, 42908, 42910, 42912, 42914, 42916, 42918, 42920, - 42932, 42934, 42936, 42938, 42940, 42942, 42946, 42931, - 65313, 65314, 65315, 65316, 65317, 65318, 65319, 65320, - 65321, 65322, 65323, 65324, 65325, 65326, 65327, 65328, - 65329, 65330, 65331, 65332, 65333, 65334, 65335, 65336, - 65337, 65338, 55297, 56320, 55297, 56321, 55297, 56322, + 65368, 65369, 65370, 94, 65313, 65314, 65315, 65316, + 65317, 65318, 65319, 65320, 65321, 65322, 65323, 65324, + 65325, 65326, 65327, 65328, 65329, 65330, 65331, 65332, + 65333, 65334, 65335, 65336, 65337, 65338, 124, 126, + 10629, 10630, 12539, 12449, 12451, 12453, 12455, 12457, + 12515, 12517, 12519, 12483, 12540, 12531, 12441, 12442, + 12644, 12593, 12594, 12595, 12596, 12597, 12598, 12599, + 12600, 12601, 12602, 12603, 12604, 12605, 12606, 12607, + 12608, 12609, 12610, 12611, 12612, 12613, 12614, 12615, + 12616, 12617, 12618, 12619, 12620, 12621, 12622, 12623, + 12624, 12625, 12626, 12627, 12628, 12629, 12630, 12631, + 12632, 12633, 12634, 12635, 12636, 12637, 12638, 12639, + 12640, 12641, 12642, 12643, 162, 163, 172, 175, + 166, 165, 8361, 9474, 8592, 8593, 8594, 8595, + 9632, 9675, 55297, 56360, 55297, 56361, 55297, 56362, + 55297, 56363, 55297, 56364, 55297, 56365, 55297, 56366, + 55297, 56367, 55297, 56368, 55297, 56369, 55297, 56370, + 55297, 56371, 55297, 56372, 55297, 56373, 55297, 56374, + 55297, 56375, 55297, 56376, 55297, 56377, 55297, 56378, + 55297, 56379, 55297, 56380, 55297, 56381, 55297, 56382, + 55297, 56383, 55297, 56384, 55297, 56385, 55297, 56386, + 55297, 56387, 55297, 56388, 55297, 56389, 55297, 56390, + 55297, 56391, 55297, 56392, 55297, 56393, 55297, 56394, + 55297, 56395, 55297, 56396, 55297, 56397, 55297, 56398, + 55297, 56399, 55297, 56320, 55297, 56321, 55297, 56322, 55297, 56323, 55297, 56324, 55297, 56325, 55297, 56326, 55297, 56327, 55297, 56328, 55297, 56329, 55297, 56330, 55297, 56331, 55297, 56332, 55297, 56333, 55297, 56334, @@ -1158,7 +1072,16 @@ static const utf8proc_uint16_t utf8proc_sequences[] = { 55297, 56347, 55297, 56348, 55297, 56349, 55297, 56350, 55297, 56351, 55297, 56352, 55297, 56353, 55297, 56354, 55297, 56355, 55297, 56356, 55297, 56357, 55297, 56358, - 55297, 56359, 55297, 56496, 55297, 56497, 55297, 56498, + 55297, 56359, 55297, 56536, 55297, 56537, 55297, 56538, + 55297, 56539, 55297, 56540, 55297, 56541, 55297, 56542, + 55297, 56543, 55297, 56544, 55297, 56545, 55297, 56546, + 55297, 56547, 55297, 56548, 55297, 56549, 55297, 56550, + 55297, 56551, 55297, 56552, 55297, 56553, 55297, 56554, + 55297, 56555, 55297, 56556, 55297, 56557, 55297, 56558, + 55297, 56559, 55297, 56560, 55297, 56561, 55297, 56562, + 55297, 56563, 55297, 56564, 55297, 56565, 55297, 56566, + 55297, 56567, 55297, 56568, 55297, 56569, 55297, 56570, + 55297, 56571, 55297, 56496, 55297, 56497, 55297, 56498, 55297, 56499, 55297, 56500, 55297, 56501, 55297, 56502, 55297, 56503, 55297, 56504, 55297, 56505, 55297, 56506, 55297, 56507, 55297, 56508, 55297, 56509, 55297, 56510, @@ -1167,44 +1090,501 @@ static const utf8proc_uint16_t utf8proc_sequences[] = { 55297, 56519, 55297, 56520, 55297, 56521, 55297, 56522, 55297, 56523, 55297, 56524, 55297, 56525, 55297, 56526, 55297, 56527, 55297, 56528, 55297, 56529, 55297, 56530, - 55297, 56531, 55299, 56448, 55299, 56449, 55299, 56450, - 55299, 56451, 55299, 56452, 55299, 56453, 55299, 56454, - 55299, 56455, 55299, 56456, 55299, 56457, 55299, 56458, - 55299, 56459, 55299, 56460, 55299, 56461, 55299, 56462, - 55299, 56463, 55299, 56464, 55299, 56465, 55299, 56466, - 55299, 56467, 55299, 56468, 55299, 56469, 55299, 56470, - 55299, 56471, 55299, 56472, 55299, 56473, 55299, 56474, - 55299, 56475, 55299, 56476, 55299, 56477, 55299, 56478, - 55299, 56479, 55299, 56480, 55299, 56481, 55299, 56482, - 55299, 56483, 55299, 56484, 55299, 56485, 55299, 56486, - 55299, 56487, 55299, 56488, 55299, 56489, 55299, 56490, - 55299, 56491, 55299, 56492, 55299, 56493, 55299, 56494, - 55299, 56495, 55299, 56496, 55299, 56497, 55299, 56498, - 55302, 56480, 55302, 56481, 55302, 56482, 55302, 56483, - 55302, 56484, 55302, 56485, 55302, 56486, 55302, 56487, - 55302, 56488, 55302, 56489, 55302, 56490, 55302, 56491, - 55302, 56492, 55302, 56493, 55302, 56494, 55302, 56495, - 55302, 56496, 55302, 56497, 55302, 56498, 55302, 56499, - 55302, 56500, 55302, 56501, 55302, 56502, 55302, 56503, - 55302, 56504, 55302, 56505, 55302, 56506, 55302, 56507, - 55302, 56508, 55302, 56509, 55302, 56510, 55302, 56511, - 55323, 56896, 55323, 56897, 55323, 56898, 55323, 56899, - 55323, 56900, 55323, 56901, 55323, 56902, 55323, 56903, - 55323, 56904, 55323, 56905, 55323, 56906, 55323, 56907, - 55323, 56908, 55323, 56909, 55323, 56910, 55323, 56911, - 55323, 56912, 55323, 56913, 55323, 56914, 55323, 56915, - 55323, 56916, 55323, 56917, 55323, 56918, 55323, 56919, - 55323, 56920, 55323, 56921, 55323, 56922, 55323, 56923, - 55323, 56924, 55323, 56925, 55323, 56926, 55323, 56927, - 55354, 56576, 55354, 56577, 55354, 56578, 55354, 56579, - 55354, 56580, 55354, 56581, 55354, 56582, 55354, 56583, - 55354, 56584, 55354, 56585, 55354, 56586, 55354, 56587, - 55354, 56588, 55354, 56589, 55354, 56590, 55354, 56591, - 55354, 56592, 55354, 56593, 55354, 56594, 55354, 56595, - 55354, 56596, 55354, 56597, 55354, 56598, 55354, 56599, - 55354, 56600, 55354, 56601, 55354, 56602, 55354, 56603, - 55354, 56604, 55354, 56605, 55354, 56606, 55354, 56607, - 55354, 56608, 55354, 56609, }; + 55297, 56531, 55297, 56727, 55297, 56728, 55297, 56729, + 55297, 56730, 55297, 56731, 55297, 56732, 55297, 56733, + 55297, 56734, 55297, 56735, 55297, 56736, 55297, 56737, + 55297, 56739, 55297, 56740, 55297, 56741, 55297, 56742, + 55297, 56743, 55297, 56744, 55297, 56745, 55297, 56746, + 55297, 56747, 55297, 56748, 55297, 56749, 55297, 56750, + 55297, 56751, 55297, 56752, 55297, 56753, 55297, 56755, + 55297, 56756, 55297, 56757, 55297, 56758, 55297, 56759, + 55297, 56760, 55297, 56761, 55297, 56763, 55297, 56764, + 55297, 56688, 55297, 56689, 55297, 56690, 55297, 56691, + 55297, 56692, 55297, 56693, 55297, 56694, 55297, 56695, + 55297, 56696, 55297, 56697, 55297, 56698, 55297, 56700, + 55297, 56701, 55297, 56702, 55297, 56703, 55297, 56704, + 55297, 56705, 55297, 56706, 55297, 56707, 55297, 56708, + 55297, 56709, 55297, 56710, 55297, 56711, 55297, 56712, + 55297, 56713, 55297, 56714, 55297, 56716, 55297, 56717, + 55297, 56718, 55297, 56719, 55297, 56720, 55297, 56721, + 55297, 56722, 55297, 56724, 55297, 56725, 55297, 57216, + 720, 721, 55297, 57219, 55297, 57220, 55297, 57221, + 55297, 57223, 55297, 57224, 55297, 57225, 55297, 57226, + 55297, 57227, 55297, 57228, 55297, 57229, 55297, 57230, + 55297, 57231, 55297, 57232, 55297, 57233, 55297, 57234, + 55297, 57235, 55297, 57236, 55297, 57237, 55297, 57238, + 55297, 57239, 55297, 57240, 55297, 57241, 55297, 57242, + 55297, 57243, 55351, 57092, 55297, 57244, 55297, 57245, + 55297, 57246, 55351, 57093, 55297, 57247, 55297, 57248, + 55351, 57094, 55297, 57249, 55297, 57250, 55297, 57251, + 55297, 57252, 55297, 57253, 55297, 57254, 55351, 57096, + 55297, 57255, 55297, 57256, 55297, 57257, 55297, 57258, + 55297, 57259, 55297, 57260, 55297, 57261, 55297, 57262, + 55297, 57263, 55297, 57264, 55297, 57266, 55297, 57267, + 55297, 57268, 55297, 57269, 448, 55297, 57270, 449, + 55297, 57271, 450, 55297, 57272, 55351, 57098, 55297, + 57273, 55351, 57118, 55297, 57274, 55299, 56512, 55299, + 56513, 55299, 56514, 55299, 56515, 55299, 56516, 55299, + 56517, 55299, 56518, 55299, 56519, 55299, 56520, 55299, + 56521, 55299, 56522, 55299, 56523, 55299, 56524, 55299, + 56525, 55299, 56526, 55299, 56527, 55299, 56528, 55299, + 56529, 55299, 56530, 55299, 56531, 55299, 56532, 55299, + 56533, 55299, 56534, 55299, 56535, 55299, 56536, 55299, + 56537, 55299, 56538, 55299, 56539, 55299, 56540, 55299, + 56541, 55299, 56542, 55299, 56543, 55299, 56544, 55299, + 56545, 55299, 56546, 55299, 56547, 55299, 56548, 55299, + 56549, 55299, 56550, 55299, 56551, 55299, 56552, 55299, + 56553, 55299, 56554, 55299, 56555, 55299, 56556, 55299, + 56557, 55299, 56558, 55299, 56559, 55299, 56560, 55299, + 56561, 55299, 56562, 55299, 56448, 55299, 56449, 55299, + 56450, 55299, 56451, 55299, 56452, 55299, 56453, 55299, + 56454, 55299, 56455, 55299, 56456, 55299, 56457, 55299, + 56458, 55299, 56459, 55299, 56460, 55299, 56461, 55299, + 56462, 55299, 56463, 55299, 56464, 55299, 56465, 55299, + 56466, 55299, 56467, 55299, 56468, 55299, 56469, 55299, + 56470, 55299, 56471, 55299, 56472, 55299, 56473, 55299, + 56474, 55299, 56475, 55299, 56476, 55299, 56477, 55299, + 56478, 55299, 56479, 55299, 56480, 55299, 56481, 55299, + 56482, 55299, 56483, 55299, 56484, 55299, 56485, 55299, + 56486, 55299, 56487, 55299, 56488, 55299, 56489, 55299, + 56490, 55299, 56491, 55299, 56492, 55299, 56493, 55299, + 56494, 55299, 56495, 55299, 56496, 55299, 56497, 55299, + 56498, 55300, 56473, 55300, 56506, 55300, 56475, 55300, + 56506, 55300, 56485, 55300, 56506, 55300, 56625, 55300, + 56615, 55300, 56626, 55300, 56615, 55300, 57159, 55300, + 57150, 55300, 57159, 55300, 57175, 55301, 56505, 55301, + 56506, 55301, 56505, 55301, 56496, 55301, 56505, 55301, + 56509, 55301, 56760, 55301, 56751, 55301, 56761, 55301, + 56751, 55302, 56512, 55302, 56513, 55302, 56514, 55302, + 56515, 55302, 56516, 55302, 56517, 55302, 56518, 55302, + 56519, 55302, 56520, 55302, 56521, 55302, 56522, 55302, + 56523, 55302, 56524, 55302, 56525, 55302, 56526, 55302, + 56527, 55302, 56528, 55302, 56529, 55302, 56530, 55302, + 56531, 55302, 56532, 55302, 56533, 55302, 56534, 55302, + 56535, 55302, 56536, 55302, 56537, 55302, 56538, 55302, + 56539, 55302, 56540, 55302, 56541, 55302, 56542, 55302, + 56543, 55302, 56480, 55302, 56481, 55302, 56482, 55302, + 56483, 55302, 56484, 55302, 56485, 55302, 56486, 55302, + 56487, 55302, 56488, 55302, 56489, 55302, 56490, 55302, + 56491, 55302, 56492, 55302, 56493, 55302, 56494, 55302, + 56495, 55302, 56496, 55302, 56497, 55302, 56498, 55302, + 56499, 55302, 56500, 55302, 56501, 55302, 56502, 55302, + 56503, 55302, 56504, 55302, 56505, 55302, 56506, 55302, + 56507, 55302, 56508, 55302, 56509, 55302, 56510, 55302, + 56511, 55302, 56629, 55302, 56624, 55323, 56928, 55323, + 56929, 55323, 56930, 55323, 56931, 55323, 56932, 55323, + 56933, 55323, 56934, 55323, 56935, 55323, 56936, 55323, + 56937, 55323, 56938, 55323, 56939, 55323, 56940, 55323, + 56941, 55323, 56942, 55323, 56943, 55323, 56944, 55323, + 56945, 55323, 56946, 55323, 56947, 55323, 56948, 55323, + 56949, 55323, 56950, 55323, 56951, 55323, 56952, 55323, + 56953, 55323, 56954, 55323, 56955, 55323, 56956, 55323, + 56957, 55323, 56958, 55323, 56959, 55323, 56896, 55323, + 56897, 55323, 56898, 55323, 56899, 55323, 56900, 55323, + 56901, 55323, 56902, 55323, 56903, 55323, 56904, 55323, + 56905, 55323, 56906, 55323, 56907, 55323, 56908, 55323, + 56909, 55323, 56910, 55323, 56911, 55323, 56912, 55323, + 56913, 55323, 56914, 55323, 56915, 55323, 56916, 55323, + 56917, 55323, 56918, 55323, 56919, 55323, 56920, 55323, + 56921, 55323, 56922, 55323, 56923, 55323, 56924, 55323, + 56925, 55323, 56926, 55323, 56927, 55348, 56663, 55348, + 56677, 55348, 56664, 55348, 56677, 55348, 56671, 55348, + 56686, 55348, 56671, 55348, 56687, 55348, 56671, 55348, + 56688, 55348, 56671, 55348, 56689, 55348, 56671, 55348, + 56690, 55348, 56761, 55348, 56677, 55348, 56762, 55348, + 56677, 55348, 56763, 55348, 56686, 55348, 56764, 55348, + 56686, 55348, 56763, 55348, 56687, 55348, 56764, 55348, + 56687, 55349, 56320, 55349, 56321, 55349, 56322, 55349, + 56323, 55349, 56324, 55349, 56325, 55349, 56326, 55349, + 56327, 55349, 56328, 55349, 56329, 55349, 56330, 55349, + 56331, 55349, 56332, 55349, 56333, 55349, 56334, 55349, + 56335, 55349, 56336, 55349, 56337, 55349, 56338, 55349, + 56339, 55349, 56340, 55349, 56341, 55349, 56342, 55349, + 56343, 55349, 56344, 55349, 56345, 55349, 56346, 55349, + 56347, 55349, 56348, 55349, 56349, 55349, 56350, 55349, + 56351, 55349, 56352, 55349, 56353, 55349, 56354, 55349, + 56355, 55349, 56356, 55349, 56357, 55349, 56358, 55349, + 56359, 55349, 56360, 55349, 56361, 55349, 56362, 55349, + 56363, 55349, 56364, 55349, 56365, 55349, 56366, 55349, + 56367, 55349, 56368, 55349, 56369, 55349, 56370, 55349, + 56371, 55349, 56372, 55349, 56373, 55349, 56374, 55349, + 56375, 55349, 56376, 55349, 56377, 55349, 56378, 55349, + 56379, 55349, 56380, 55349, 56381, 55349, 56382, 55349, + 56383, 55349, 56384, 55349, 56385, 55349, 56386, 55349, + 56387, 55349, 56388, 55349, 56389, 55349, 56390, 55349, + 56391, 55349, 56392, 55349, 56393, 55349, 56394, 55349, + 56395, 55349, 56396, 55349, 56397, 55349, 56398, 55349, + 56399, 55349, 56400, 55349, 56401, 55349, 56402, 55349, + 56403, 55349, 56404, 55349, 56406, 55349, 56407, 55349, + 56408, 55349, 56409, 55349, 56410, 55349, 56411, 55349, + 56412, 55349, 56413, 55349, 56414, 55349, 56415, 55349, + 56416, 55349, 56417, 55349, 56418, 55349, 56419, 55349, + 56420, 55349, 56421, 55349, 56422, 55349, 56423, 55349, + 56424, 55349, 56425, 55349, 56426, 55349, 56427, 55349, + 56428, 55349, 56429, 55349, 56430, 55349, 56431, 55349, + 56432, 55349, 56433, 55349, 56434, 55349, 56435, 55349, + 56436, 55349, 56437, 55349, 56438, 55349, 56439, 55349, + 56440, 55349, 56441, 55349, 56442, 55349, 56443, 55349, + 56444, 55349, 56445, 55349, 56446, 55349, 56447, 55349, + 56448, 55349, 56449, 55349, 56450, 55349, 56451, 55349, + 56452, 55349, 56453, 55349, 56454, 55349, 56455, 55349, + 56456, 55349, 56457, 55349, 56458, 55349, 56459, 55349, + 56460, 55349, 56461, 55349, 56462, 55349, 56463, 55349, + 56464, 55349, 56465, 55349, 56466, 55349, 56467, 55349, + 56468, 55349, 56469, 55349, 56470, 55349, 56471, 55349, + 56472, 55349, 56473, 55349, 56474, 55349, 56475, 55349, + 56476, 55349, 56478, 55349, 56479, 55349, 56482, 55349, + 56485, 55349, 56486, 55349, 56489, 55349, 56490, 55349, + 56491, 55349, 56492, 55349, 56494, 55349, 56495, 55349, + 56496, 55349, 56497, 55349, 56498, 55349, 56499, 55349, + 56500, 55349, 56501, 55349, 56502, 55349, 56503, 55349, + 56504, 55349, 56505, 55349, 56507, 55349, 56509, 55349, + 56510, 55349, 56511, 55349, 56512, 55349, 56513, 55349, + 56514, 55349, 56515, 55349, 56517, 55349, 56518, 55349, + 56519, 55349, 56520, 55349, 56521, 55349, 56522, 55349, + 56523, 55349, 56524, 55349, 56525, 55349, 56526, 55349, + 56527, 55349, 56528, 55349, 56529, 55349, 56530, 55349, + 56531, 55349, 56532, 55349, 56533, 55349, 56534, 55349, + 56535, 55349, 56536, 55349, 56537, 55349, 56538, 55349, + 56539, 55349, 56540, 55349, 56541, 55349, 56542, 55349, + 56543, 55349, 56544, 55349, 56545, 55349, 56546, 55349, + 56547, 55349, 56548, 55349, 56549, 55349, 56550, 55349, + 56551, 55349, 56552, 55349, 56553, 55349, 56554, 55349, + 56555, 55349, 56556, 55349, 56557, 55349, 56558, 55349, + 56559, 55349, 56560, 55349, 56561, 55349, 56562, 55349, + 56563, 55349, 56564, 55349, 56565, 55349, 56566, 55349, + 56567, 55349, 56568, 55349, 56569, 55349, 56570, 55349, + 56571, 55349, 56572, 55349, 56573, 55349, 56574, 55349, + 56575, 55349, 56576, 55349, 56577, 55349, 56578, 55349, + 56579, 55349, 56580, 55349, 56581, 55349, 56583, 55349, + 56584, 55349, 56585, 55349, 56586, 55349, 56589, 55349, + 56590, 55349, 56591, 55349, 56592, 55349, 56593, 55349, + 56594, 55349, 56595, 55349, 56596, 55349, 56598, 55349, + 56599, 55349, 56600, 55349, 56601, 55349, 56602, 55349, + 56603, 55349, 56604, 55349, 56606, 55349, 56607, 55349, + 56608, 55349, 56609, 55349, 56610, 55349, 56611, 55349, + 56612, 55349, 56613, 55349, 56614, 55349, 56615, 55349, + 56616, 55349, 56617, 55349, 56618, 55349, 56619, 55349, + 56620, 55349, 56621, 55349, 56622, 55349, 56623, 55349, + 56624, 55349, 56625, 55349, 56626, 55349, 56627, 55349, + 56628, 55349, 56629, 55349, 56630, 55349, 56631, 55349, + 56632, 55349, 56633, 55349, 56635, 55349, 56636, 55349, + 56637, 55349, 56638, 55349, 56640, 55349, 56641, 55349, + 56642, 55349, 56643, 55349, 56644, 55349, 56646, 55349, + 56650, 55349, 56651, 55349, 56652, 55349, 56653, 55349, + 56654, 55349, 56655, 55349, 56656, 55349, 56658, 55349, + 56659, 55349, 56660, 55349, 56661, 55349, 56662, 55349, + 56663, 55349, 56664, 55349, 56665, 55349, 56666, 55349, + 56667, 55349, 56668, 55349, 56669, 55349, 56670, 55349, + 56671, 55349, 56672, 55349, 56673, 55349, 56674, 55349, + 56675, 55349, 56676, 55349, 56677, 55349, 56678, 55349, + 56679, 55349, 56680, 55349, 56681, 55349, 56682, 55349, + 56683, 55349, 56684, 55349, 56685, 55349, 56686, 55349, + 56687, 55349, 56688, 55349, 56689, 55349, 56690, 55349, + 56691, 55349, 56692, 55349, 56693, 55349, 56694, 55349, + 56695, 55349, 56696, 55349, 56697, 55349, 56698, 55349, + 56699, 55349, 56700, 55349, 56701, 55349, 56702, 55349, + 56703, 55349, 56704, 55349, 56705, 55349, 56706, 55349, + 56707, 55349, 56708, 55349, 56709, 55349, 56710, 55349, + 56711, 55349, 56712, 55349, 56713, 55349, 56714, 55349, + 56715, 55349, 56716, 55349, 56717, 55349, 56718, 55349, + 56719, 55349, 56720, 55349, 56721, 55349, 56722, 55349, + 56723, 55349, 56724, 55349, 56725, 55349, 56726, 55349, + 56727, 55349, 56728, 55349, 56729, 55349, 56730, 55349, + 56731, 55349, 56732, 55349, 56733, 55349, 56734, 55349, + 56735, 55349, 56736, 55349, 56737, 55349, 56738, 55349, + 56739, 55349, 56740, 55349, 56741, 55349, 56742, 55349, + 56743, 55349, 56744, 55349, 56745, 55349, 56746, 55349, + 56747, 55349, 56748, 55349, 56749, 55349, 56750, 55349, + 56751, 55349, 56752, 55349, 56753, 55349, 56754, 55349, + 56755, 55349, 56756, 55349, 56757, 55349, 56758, 55349, + 56759, 55349, 56760, 55349, 56761, 55349, 56762, 55349, + 56763, 55349, 56764, 55349, 56765, 55349, 56766, 55349, + 56767, 55349, 56768, 55349, 56769, 55349, 56770, 55349, + 56771, 55349, 56772, 55349, 56773, 55349, 56774, 55349, + 56775, 55349, 56776, 55349, 56777, 55349, 56778, 55349, + 56779, 55349, 56780, 55349, 56781, 55349, 56782, 55349, + 56783, 55349, 56784, 55349, 56785, 55349, 56786, 55349, + 56787, 55349, 56788, 55349, 56789, 55349, 56790, 55349, + 56791, 55349, 56792, 55349, 56793, 55349, 56794, 55349, + 56795, 55349, 56796, 55349, 56797, 55349, 56798, 55349, + 56799, 55349, 56800, 55349, 56801, 55349, 56802, 55349, + 56803, 55349, 56804, 55349, 56805, 55349, 56806, 55349, + 56807, 55349, 56808, 55349, 56809, 55349, 56810, 55349, + 56811, 55349, 56812, 55349, 56813, 55349, 56814, 55349, + 56815, 55349, 56816, 55349, 56817, 55349, 56818, 55349, + 56819, 55349, 56820, 55349, 56821, 55349, 56822, 55349, + 56823, 55349, 56824, 55349, 56825, 55349, 56826, 55349, + 56827, 55349, 56828, 55349, 56829, 55349, 56830, 55349, + 56831, 55349, 56832, 55349, 56833, 55349, 56834, 55349, + 56835, 55349, 56836, 55349, 56837, 55349, 56838, 55349, + 56839, 55349, 56840, 55349, 56841, 55349, 56842, 55349, + 56843, 55349, 56844, 55349, 56845, 55349, 56846, 55349, + 56847, 55349, 56848, 55349, 56849, 55349, 56850, 55349, + 56851, 55349, 56852, 55349, 56853, 55349, 56854, 55349, + 56855, 55349, 56856, 55349, 56857, 55349, 56858, 55349, + 56859, 55349, 56860, 55349, 56861, 55349, 56862, 55349, + 56863, 55349, 56864, 55349, 56865, 55349, 56866, 55349, + 56867, 55349, 56868, 55349, 56869, 55349, 56870, 55349, + 56871, 55349, 56872, 55349, 56873, 55349, 56874, 55349, + 56875, 55349, 56876, 55349, 56877, 55349, 56878, 55349, + 56879, 55349, 56880, 55349, 56881, 55349, 56882, 55349, + 56883, 55349, 56884, 55349, 56885, 55349, 56886, 55349, + 56887, 55349, 56888, 55349, 56889, 55349, 56890, 55349, + 56891, 55349, 56892, 55349, 56893, 55349, 56894, 55349, + 56895, 55349, 56896, 55349, 56897, 55349, 56898, 55349, + 56899, 55349, 56900, 55349, 56901, 55349, 56902, 55349, + 56903, 55349, 56904, 55349, 56905, 55349, 56906, 55349, + 56907, 55349, 56908, 55349, 56909, 55349, 56910, 55349, + 56911, 55349, 56912, 55349, 56913, 55349, 56914, 55349, + 56915, 55349, 56916, 55349, 56917, 55349, 56918, 55349, + 56919, 55349, 56920, 55349, 56921, 55349, 56922, 55349, + 56923, 55349, 56924, 55349, 56925, 55349, 56926, 55349, + 56927, 55349, 56928, 55349, 56929, 55349, 56930, 55349, + 56931, 55349, 56932, 55349, 56933, 55349, 56934, 55349, + 56935, 55349, 56936, 55349, 56937, 55349, 56938, 55349, + 56939, 55349, 56940, 55349, 56941, 55349, 56942, 55349, + 56943, 55349, 56944, 55349, 56945, 55349, 56946, 55349, + 56947, 55349, 56948, 55349, 56949, 55349, 56950, 55349, + 56951, 55349, 56952, 55349, 56953, 55349, 56954, 55349, + 56955, 55349, 56956, 55349, 56957, 55349, 56958, 55349, + 56959, 55349, 56960, 55349, 56961, 55349, 56962, 55349, + 56963, 55349, 56964, 55349, 56965, 55349, 56966, 55349, + 56967, 55349, 56968, 55349, 56969, 55349, 56970, 55349, + 56971, 55349, 56972, 55349, 56973, 55349, 56974, 55349, + 56975, 55349, 56976, 55349, 56977, 55349, 56978, 55349, + 56979, 55349, 56980, 55349, 56981, 55349, 56982, 55349, + 56983, 55349, 56984, 55349, 56985, 55349, 56986, 55349, + 56987, 55349, 56988, 55349, 56989, 55349, 56990, 55349, + 56991, 55349, 56992, 55349, 56993, 55349, 56994, 55349, + 56995, 305, 55349, 56996, 55349, 56997, 55349, 57000, + 55349, 57001, 55349, 57002, 55349, 57003, 55349, 57004, + 55349, 57005, 55349, 57006, 55349, 57007, 55349, 57008, + 55349, 57009, 55349, 57010, 55349, 57011, 55349, 57012, + 55349, 57013, 55349, 57014, 55349, 57015, 55349, 57016, + 1012, 55349, 57017, 55349, 57018, 55349, 57019, 55349, + 57020, 55349, 57021, 55349, 57022, 55349, 57023, 55349, + 57024, 8711, 55349, 57026, 55349, 57027, 55349, 57028, + 55349, 57029, 55349, 57030, 55349, 57031, 55349, 57032, + 55349, 57033, 55349, 57034, 55349, 57035, 55349, 57036, + 55349, 57037, 55349, 57038, 55349, 57039, 55349, 57040, + 55349, 57041, 55349, 57042, 55349, 57043, 55349, 57044, + 55349, 57045, 55349, 57046, 55349, 57047, 55349, 57048, + 55349, 57049, 55349, 57050, 8706, 1013, 55349, 57052, + 977, 55349, 57053, 1008, 55349, 57054, 981, 55349, + 57055, 1009, 55349, 57056, 982, 55349, 57057, 55349, + 57058, 55349, 57059, 55349, 57060, 55349, 57061, 55349, + 57062, 55349, 57063, 55349, 57064, 55349, 57065, 55349, + 57066, 55349, 57067, 55349, 57068, 55349, 57069, 55349, + 57070, 55349, 57071, 55349, 57072, 55349, 57073, 55349, + 57074, 55349, 57075, 55349, 57076, 55349, 57077, 55349, + 57078, 55349, 57079, 55349, 57080, 55349, 57081, 55349, + 57082, 55349, 57084, 55349, 57085, 55349, 57086, 55349, + 57087, 55349, 57088, 55349, 57089, 55349, 57090, 55349, + 57091, 55349, 57092, 55349, 57093, 55349, 57094, 55349, + 57095, 55349, 57096, 55349, 57097, 55349, 57098, 55349, + 57099, 55349, 57100, 55349, 57101, 55349, 57102, 55349, + 57103, 55349, 57104, 55349, 57105, 55349, 57106, 55349, + 57107, 55349, 57108, 55349, 57110, 55349, 57111, 55349, + 57112, 55349, 57113, 55349, 57114, 55349, 57115, 55349, + 57116, 55349, 57117, 55349, 57118, 55349, 57119, 55349, + 57120, 55349, 57121, 55349, 57122, 55349, 57123, 55349, + 57124, 55349, 57125, 55349, 57126, 55349, 57127, 55349, + 57128, 55349, 57129, 55349, 57130, 55349, 57131, 55349, + 57132, 55349, 57133, 55349, 57134, 55349, 57135, 55349, + 57136, 55349, 57137, 55349, 57138, 55349, 57139, 55349, + 57140, 55349, 57142, 55349, 57143, 55349, 57144, 55349, + 57145, 55349, 57146, 55349, 57147, 55349, 57148, 55349, + 57149, 55349, 57150, 55349, 57151, 55349, 57152, 55349, + 57153, 55349, 57154, 55349, 57155, 55349, 57156, 55349, + 57157, 55349, 57158, 55349, 57159, 55349, 57160, 55349, + 57161, 55349, 57162, 55349, 57163, 55349, 57164, 55349, + 57165, 55349, 57166, 55349, 57168, 55349, 57169, 55349, + 57170, 55349, 57171, 55349, 57172, 55349, 57173, 55349, + 57174, 55349, 57175, 55349, 57176, 55349, 57177, 55349, + 57178, 55349, 57179, 55349, 57180, 55349, 57181, 55349, + 57182, 55349, 57183, 55349, 57184, 55349, 57185, 55349, + 57186, 55349, 57187, 55349, 57188, 55349, 57189, 55349, + 57190, 55349, 57191, 55349, 57192, 55349, 57193, 55349, + 57194, 55349, 57195, 55349, 57196, 55349, 57197, 55349, + 57198, 55349, 57200, 55349, 57201, 55349, 57202, 55349, + 57203, 55349, 57204, 55349, 57205, 55349, 57206, 55349, + 57207, 55349, 57208, 55349, 57209, 55349, 57210, 55349, + 57211, 55349, 57212, 55349, 57213, 55349, 57214, 55349, + 57215, 55349, 57216, 55349, 57217, 55349, 57218, 55349, + 57219, 55349, 57220, 55349, 57221, 55349, 57222, 55349, + 57223, 55349, 57224, 55349, 57226, 55349, 57227, 55349, + 57228, 55349, 57229, 55349, 57230, 55349, 57231, 55349, + 57232, 55349, 57233, 55349, 57234, 55349, 57235, 55349, + 57236, 55349, 57237, 55349, 57238, 55349, 57239, 55349, + 57240, 55349, 57241, 55349, 57242, 55349, 57243, 55349, + 57244, 55349, 57245, 55349, 57246, 55349, 57247, 55349, + 57248, 55349, 57249, 55349, 57250, 55349, 57251, 55349, + 57252, 55349, 57253, 55349, 57254, 55349, 57255, 55349, + 57256, 55349, 57258, 55349, 57259, 55349, 57260, 55349, + 57261, 55349, 57262, 55349, 57263, 55349, 57264, 55349, + 57265, 55349, 57266, 55349, 57267, 55349, 57268, 55349, + 57269, 55349, 57270, 55349, 57271, 55349, 57272, 55349, + 57273, 55349, 57274, 55349, 57275, 55349, 57276, 55349, + 57277, 55349, 57278, 55349, 57279, 55349, 57280, 55349, + 57281, 55349, 57282, 55349, 57284, 55349, 57285, 55349, + 57286, 55349, 57287, 55349, 57288, 55349, 57289, 55349, + 57290, 55349, 57291, 55351, 57088, 55351, 57089, 55351, + 57090, 55351, 57091, 55351, 57095, 55351, 57097, 55351, + 57099, 55351, 57100, 55351, 57101, 55351, 57102, 55351, + 57103, 55351, 57104, 55351, 57105, 55351, 57106, 55351, + 57107, 55351, 57108, 55351, 57109, 55351, 57110, 55351, + 57111, 55351, 57112, 55351, 57113, 55351, 57114, 55351, + 57115, 55351, 57116, 55351, 57117, 55351, 57125, 55351, + 57126, 55351, 57127, 55351, 57128, 55351, 57129, 55351, + 57130, 55352, 56368, 55352, 56369, 55352, 56370, 55352, + 56371, 55352, 56372, 55352, 56373, 55352, 56374, 55352, + 56375, 55352, 56376, 55352, 56377, 55352, 56378, 55352, + 56379, 55352, 56380, 55352, 56381, 55352, 56382, 55352, + 56383, 55352, 56384, 55352, 56385, 55352, 56386, 55352, + 56387, 55352, 56388, 55352, 56389, 55352, 56390, 55352, + 56391, 55352, 56392, 55352, 56393, 55352, 56394, 55352, + 56395, 55352, 56396, 55352, 56397, 55352, 56398, 55352, + 56399, 55352, 56400, 55352, 56401, 55352, 56402, 55352, + 56403, 55352, 56404, 55352, 56405, 55352, 56406, 55352, + 56407, 55352, 56408, 55352, 56409, 55352, 56410, 55352, + 56411, 55352, 56412, 55352, 56413, 55352, 56414, 55352, + 56415, 55352, 56416, 55352, 56417, 55352, 56418, 55352, + 56419, 55352, 56420, 55352, 56421, 55352, 56422, 55352, + 56423, 55352, 56424, 55352, 56425, 55352, 56426, 55352, + 56427, 55352, 56428, 55352, 56429, 55354, 56610, 55354, + 56611, 55354, 56612, 55354, 56613, 55354, 56614, 55354, + 56615, 55354, 56616, 55354, 56617, 55354, 56618, 55354, + 56619, 55354, 56620, 55354, 56621, 55354, 56622, 55354, + 56623, 55354, 56624, 55354, 56625, 55354, 56626, 55354, + 56627, 55354, 56628, 55354, 56629, 55354, 56630, 55354, + 56631, 55354, 56632, 55354, 56633, 55354, 56634, 55354, + 56635, 55354, 56636, 55354, 56637, 55354, 56638, 55354, + 56639, 55354, 56640, 55354, 56641, 55354, 56642, 55354, + 56643, 55354, 56576, 55354, 56577, 55354, 56578, 55354, + 56579, 55354, 56580, 55354, 56581, 55354, 56582, 55354, + 56583, 55354, 56584, 55354, 56585, 55354, 56586, 55354, + 56587, 55354, 56588, 55354, 56589, 55354, 56590, 55354, + 56591, 55354, 56592, 55354, 56593, 55354, 56594, 55354, + 56595, 55354, 56596, 55354, 56597, 55354, 56598, 55354, + 56599, 55354, 56600, 55354, 56601, 55354, 56602, 55354, + 56603, 55354, 56604, 55354, 56605, 55354, 56606, 55354, + 56607, 55354, 56608, 55354, 56609, 1646, 1697, 1647, + 48, 46, 48, 44, 49, 44, 50, 44, + 51, 44, 52, 44, 53, 44, 54, 44, + 55, 44, 56, 44, 57, 44, 40, 65, + 41, 40, 66, 41, 40, 67, 41, 40, + 68, 41, 40, 69, 41, 40, 70, 41, + 40, 71, 41, 40, 72, 41, 40, 73, + 41, 40, 74, 41, 40, 75, 41, 40, + 76, 41, 40, 77, 41, 40, 78, 41, + 40, 79, 41, 40, 80, 41, 40, 81, + 41, 40, 82, 41, 40, 83, 41, 40, + 84, 41, 40, 85, 41, 40, 86, 41, + 40, 87, 41, 40, 88, 41, 40, 89, + 41, 40, 90, 41, 12308, 83, 12309, 67, + 68, 87, 90, 55356, 56624, 55356, 56625, 55356, + 56626, 55356, 56627, 55356, 56628, 55356, 56629, 55356, + 56630, 55356, 56631, 55356, 56632, 55356, 56633, 55356, + 56634, 55356, 56635, 55356, 56636, 55356, 56637, 55356, + 56638, 55356, 56639, 55356, 56640, 55356, 56641, 55356, + 56642, 55356, 56643, 55356, 56644, 55356, 56645, 55356, + 56646, 55356, 56647, 55356, 56648, 55356, 56649, 72, + 86, 83, 68, 83, 83, 80, 80, 86, + 87, 67, 55356, 56656, 55356, 56657, 55356, 56658, + 55356, 56659, 55356, 56660, 55356, 56661, 55356, 56662, + 55356, 56663, 55356, 56664, 55356, 56665, 55356, 56666, + 55356, 56667, 55356, 56668, 55356, 56669, 55356, 56670, + 55356, 56671, 55356, 56672, 55356, 56673, 55356, 56674, + 55356, 56675, 55356, 56676, 55356, 56677, 55356, 56678, + 55356, 56679, 55356, 56680, 55356, 56681, 77, 67, + 77, 68, 77, 82, 55356, 56688, 55356, 56689, + 55356, 56690, 55356, 56691, 55356, 56692, 55356, 56693, + 55356, 56694, 55356, 56695, 55356, 56696, 55356, 56697, + 55356, 56698, 55356, 56699, 55356, 56700, 55356, 56701, + 55356, 56702, 55356, 56703, 55356, 56704, 55356, 56705, + 55356, 56706, 55356, 56707, 55356, 56708, 55356, 56709, + 55356, 56710, 55356, 56711, 55356, 56712, 55356, 56713, + 68, 74, 12411, 12363, 12467, 12467, 23383, 21452, + 12487, 22810, 35299, 20132, 26144, 28961, 21069, 24460, + 20877, 26032, 21021, 32066, 36009, 22768, 21561, 28436, + 25237, 25429, 36938, 25351, 25171, 31105, 31354, 21512, + 28288, 30003, 21106, 21942, 37197, 12308, 26412, 12309, + 12308, 19977, 12309, 12308, 20108, 12309, 12308, 23433, + 12309, 12308, 28857, 12309, 12308, 25171, 12309, 12308, + 30423, 12309, 12308, 21213, 12309, 12308, 25943, 12309, + 24471, 21487, 20029, 20024, 20033, 55360, 56610, 20320, + 20411, 20482, 20602, 20633, 20687, 13470, 55361, 56890, + 20820, 20836, 20855, 55361, 56604, 13497, 20839, 55361, + 56651, 20887, 20900, 20172, 20908, 55396, 56799, 20995, + 13535, 21051, 21062, 21111, 13589, 21253, 21254, 21321, + 21338, 21363, 21373, 21375, 55362, 56876, 28784, 21450, + 21471, 55362, 57187, 21483, 21489, 21510, 21662, 21560, + 21576, 21608, 21666, 21750, 21776, 21843, 21859, 21892, + 21931, 21939, 21954, 22294, 22295, 22097, 22132, 22766, + 22478, 22516, 22541, 22411, 22578, 22577, 22700, 55365, + 56548, 22770, 22775, 22790, 22818, 22882, 55365, 57000, + 55365, 57066, 23020, 23067, 23079, 23000, 23142, 14062, + 14076, 23304, 23358, 55366, 56776, 23491, 23512, 23539, + 55366, 57112, 23551, 23558, 24403, 14209, 23648, 23744, + 23693, 55367, 56804, 23875, 55367, 56806, 23918, 23915, + 23932, 24033, 24034, 14383, 24061, 24104, 24125, 24169, + 14434, 55368, 56707, 14460, 24240, 24243, 24246, 55400, + 57234, 55368, 57137, 33281, 24354, 14535, 55372, 57016, + 55384, 56794, 24418, 24427, 14563, 24474, 24525, 24535, + 24569, 24705, 14650, 14620, 55369, 57044, 24775, 24904, + 24908, 24954, 25010, 24996, 25007, 25054, 25104, 25115, + 25181, 25265, 25300, 25424, 55370, 57100, 25405, 25340, + 25448, 25475, 25572, 55370, 57329, 25634, 25541, 25513, + 14894, 25705, 25726, 25757, 25719, 14956, 25964, 55372, + 56330, 26083, 26360, 26185, 15129, 15112, 15076, 20882, + 20885, 26368, 26268, 32941, 17369, 26401, 26462, 26451, + 55372, 57283, 15177, 26618, 26501, 26706, 55373, 56429, + 26766, 26655, 26900, 26946, 27043, 27114, 27304, 55373, + 56995, 27355, 15384, 27425, 55374, 56487, 27476, 15438, + 27506, 27551, 27579, 55374, 56973, 55367, 56587, 55374, + 57082, 27726, 55375, 56508, 27839, 27853, 27751, 27926, + 27966, 28009, 28024, 28037, 55375, 56606, 27956, 28207, + 28270, 15667, 28359, 55375, 57041, 28153, 28526, 55375, + 57182, 55375, 57230, 28614, 28729, 28699, 15766, 28746, + 28797, 28791, 28845, 55361, 56613, 28997, 55376, 56931, + 29084, 55376, 57259, 29224, 29264, 55377, 56840, 29312, + 29333, 55377, 57141, 55378, 56340, 29562, 29579, 16044, + 29605, 16056, 29767, 29788, 29829, 29898, 16155, 29988, + 55379, 56374, 30014, 55379, 56466, 55368, 56735, 30224, + 55379, 57249, 55379, 57272, 55380, 56388, 16380, 16392, + 55380, 56563, 55380, 56562, 55380, 56601, 55380, 56627, + 30494, 30495, 30603, 16454, 16534, 55381, 56349, 30798, + 16611, 55381, 56870, 55381, 56986, 55381, 57029, 31211, + 16687, 31306, 31311, 55382, 56700, 55382, 56999, 31470, + 16898, 55382, 57259, 31686, 31689, 16935, 55383, 56448, + 31954, 17056, 31976, 31971, 32000, 55383, 57222, 32099, + 17153, 32199, 32258, 32325, 17204, 55384, 56872, 55384, + 56903, 17241, 55384, 57049, 32634, 55384, 57150, 32661, + 32762, 55385, 56538, 55385, 56611, 32864, 55385, 56744, + 32880, 55372, 57183, 17365, 32946, 33027, 17419, 33086, + 23221, 55385, 57255, 55385, 57269, 55372, 57235, 55372, + 57244, 33284, 36766, 17515, 33425, 33419, 33437, 21171, + 33457, 33459, 33469, 33510, 55386, 57148, 33565, 33635, + 33709, 33571, 33725, 33767, 33619, 33738, 33740, 33756, + 55387, 56374, 55387, 56683, 55387, 56533, 17707, 34033, + 34035, 34070, 55388, 57290, 34148, 55387, 57132, 17757, + 17761, 55387, 57265, 55388, 56530, 17771, 34384, 34407, + 34409, 34473, 34440, 34574, 34530, 34600, 34667, 34694, + 17879, 34785, 34817, 17913, 34912, 55389, 56935, 35031, + 35038, 17973, 35066, 13499, 55390, 56494, 55390, 56678, + 18110, 18119, 35488, 55391, 56488, 36011, 36033, 36123, + 36215, 55391, 57135, 55362, 56324, 36299, 36284, 36336, + 55362, 56542, 36564, 55393, 56786, 55393, 56813, 37012, + 37105, 37137, 55393, 57134, 37147, 37432, 37591, 37592, + 37500, 37881, 37909, 55394, 57338, 38283, 18837, 38327, + 55395, 56695, 18918, 38595, 23986, 38691, 55396, 56645, + 55396, 56858, 19054, 19062, 38880, 55397, 56330, 19122, + 55397, 56470, 38953, 55397, 56758, 39138, 19251, 39209, + 39335, 39362, 39422, 19406, 55398, 57136, 40000, 40189, + 19662, 19693, 40295, 55400, 56526, 19704, 55400, 56581, + 55400, 56846, 55400, 56977, 19798, 40702, 40709, 40719, + 40726, 55401, 56832, }; static const utf8proc_uint16_t utf8proc_stage1table[] = { 0, 256, 512, 768, 1024, 1280, 1536, @@ -1227,51 +1607,51 @@ static const utf8proc_uint16_t utf8proc_stage1table[] = { 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, - 13824, 14080, 13312, 13312, 13312, 14336, 5376, 14592, - 14848, 15104, 15360, 15616, 15872, 16128, 16384, 16640, - 16896, 17152, 17408, 17664, 16128, 16384, 16640, 16896, - 17152, 17408, 17664, 16128, 16384, 16640, 16896, 17152, - 17408, 17664, 16128, 16384, 16640, 16896, 17152, 17408, - 17664, 16128, 16384, 16640, 16896, 17152, 17408, 17664, - 16128, 16384, 16640, 16896, 17152, 17408, 17664, 16128, + 13312, 13824, 13312, 13312, 13312, 14080, 5376, 14336, + 14592, 14848, 15104, 15360, 15616, 15872, 16128, 16384, + 16640, 16896, 17152, 17408, 15872, 16128, 16384, 16640, + 16896, 17152, 17408, 15872, 16128, 16384, 16640, 16896, + 17152, 17408, 15872, 16128, 16384, 16640, 16896, 17152, + 17408, 15872, 16128, 16384, 16640, 16896, 17152, 17408, + 15872, 16128, 16384, 16640, 16896, 17152, 17408, 15872, + 17664, 17920, 17920, 17920, 17920, 17920, 17920, 17920, 17920, 18176, 18176, 18176, 18176, 18176, 18176, 18176, - 18176, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18688, 18944, 19200, 19456, 19712, 19968, - 20224, 20480, 20736, 20992, 21248, 21504, 21760, 5376, - 22016, 22272, 22528, 22784, 23040, 23296, 23552, 23808, - 24064, 24320, 24576, 24832, 25088, 25344, 25600, 25856, - 26112, 26368, 26624, 26880, 27136, 27392, 27648, 27904, - 28160, 5376, 5376, 5376, 28416, 28672, 28928, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 5376, 5376, 5376, 5376, 29184, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 5376, 5376, 29440, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 5376, 5376, 29696, 29952, 27136, 27136, 30208, - 30464, 13312, 13312, 13312, 13312, 13312, 13312, 13312, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18432, 18688, 18944, 19200, 19456, 19712, + 19968, 20224, 20480, 20736, 20992, 21248, 21504, 5376, + 21760, 22016, 22272, 22528, 22784, 23040, 23296, 23552, + 23808, 24064, 24320, 24576, 24832, 25088, 25344, 25600, + 25856, 26112, 26368, 26624, 26880, 27136, 27392, 27648, + 27904, 5376, 5376, 5376, 28160, 28416, 28672, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 29184, 5376, 5376, 5376, 5376, 29440, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 5376, 5376, 29696, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 5376, 5376, 29952, 30208, 28928, 28928, 30464, + 30720, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, - 30720, 13312, 13312, 30976, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 13312, 31232, 31488, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 31744, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 32000, 32256, 32512, 32768, 33024, 33280, 33536, - 33792, 10240, 10240, 34048, 27136, 27136, 27136, 27136, - 27136, 34304, 34560, 34816, 27136, 27136, 27136, 27136, - 27136, 35072, 35328, 27136, 27136, 35584, 35840, 36096, - 27136, 36352, 36608, 36864, 37120, 37376, 37632, 37888, - 38144, 38400, 38656, 38912, 27136, 27136, 27136, 27136, - 27136, 13312, 13312, 13312, 13312, 13312, 13312, 13312, + 30976, 13312, 13312, 13312, 13312, 31232, 31488, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 31744, 13312, 32000, 32256, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 32512, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 32768, 33024, 33280, 33536, 33792, 34048, 34304, 34560, + 34816, 10240, 10240, 35072, 28928, 28928, 28928, 28928, + 35328, 35584, 35840, 36096, 28928, 36352, 28928, 28928, + 36608, 36864, 37120, 28928, 28928, 37376, 37632, 37888, + 28928, 38144, 38400, 38656, 38912, 39168, 39424, 39680, + 39936, 40192, 40448, 40704, 40960, 28928, 28928, 28928, + 28928, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, @@ -1291,605 +1671,596 @@ static const utf8proc_uint16_t utf8proc_stage1table[] = { 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, - 13312, 13312, 13312, 13312, 13312, 13312, 13312, 39168, + 13312, 13312, 13312, 13312, 13312, 13312, 13312, 41216, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, - 39424, 39680, 13312, 13312, 13312, 13312, 13312, 13312, + 41472, 41728, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, - 13312, 13312, 13312, 13312, 13312, 13312, 13312, 39936, + 13312, 13312, 13312, 13312, 13312, 13312, 13312, 41984, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, - 13312, 13312, 13312, 13312, 40192, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 40448, 40704, 40960, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 41216, 41472, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, - 27136, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 41728, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, - 41728, }; + 13312, 13312, 13312, 13312, 42240, 13312, 13312, 42496, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 42752, 43008, 43264, 28928, 28928, 28928, 28928, + 28928, 13312, 13312, 13312, 13312, 13312, 13312, 13312, + 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, + 13312, 13312, 13312, 13312, 43520, 13312, 13312, 13312, + 13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, + 13312, 13312, 13312, 13312, 43776, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 44032, 44288, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 28928, 28928, 28928, 28928, 28928, 28928, 28928, + 28928, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 44544, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 18176, 18176, 18176, 18176, 18176, 18176, 18176, 18176, + 44544, }; static const utf8proc_uint16_t utf8proc_stage2table[] = { - 1, 2, 2, 2, 2, 2, 2, - 2, 2, 3, 4, 3, 5, 6, 2, - 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 7, 7, 7, - 3, 8, 9, 9, 10, 11, 10, 9, - 9, 12, 13, 9, 14, 15, 16, 15, - 15, 17, 17, 17, 17, 17, 17, 17, - 17, 17, 17, 15, 9, 18, 19, 20, - 9, 9, 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, 12, 9, 13, 47, - 48, 47, 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, 12, 75, 13, 75, - 2, 2, 2, 2, 2, 2, 7, 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, 76, 9, 11, 11, 11, 11, 77, - 9, 78, 79, 80, 81, 75, 82, 79, - 83, 84, 85, 86, 87, 88, 89, 9, - 9, 90, 91, 92, 93, 94, 95, 96, - 9, 97, 98, 99, 100, 101, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, 117, 118, 119, - 75, 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, - 75, 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, 215, 300, + 1, 1, 1, 1, 1, 1, 1, + 1, 1, 2, 3, 2, 4, 5, 1, + 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 6, 6, 6, + 2, 7, 8, 8, 9, 10, 9, 8, + 8, 11, 12, 8, 13, 14, 15, 14, + 14, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 14, 8, 17, 18, 19, + 8, 8, 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, 11, 8, 12, 46, + 47, 46, 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, 11, 74, 12, 74, + 1, 1, 1, 1, 1, 1, 6, 1, + 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, + 1, 75, 8, 10, 10, 10, 10, 76, + 8, 77, 78, 79, 80, 74, 81, 78, + 82, 83, 84, 85, 86, 87, 88, 8, + 8, 89, 90, 91, 92, 93, 94, 95, + 8, 96, 97, 98, 99, 100, 101, 102, + 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, + 74, 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, + 74, 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, 215, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 322, 323, - 324, 325, 326, 215, 215, 327, 328, 329, - 330, 331, 332, 333, 334, 335, 336, 337, - 338, 339, 340, 215, 341, 342, 343, 215, - 344, 341, 341, 341, 341, 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, 215, 438, 439, 440, 441, 442, - 443, 444, 445, 446, 447, 448, 449, 450, - 451, 452, 453, 454, 455, 215, 215, 215, - 215, 215, 215, 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, 215, 483, - 484, 215, 485, 215, 486, 487, 215, 215, - 215, 488, 489, 215, 490, 215, 491, 492, - 215, 493, 494, 495, 496, 497, 215, 215, - 498, 215, 499, 500, 215, 215, 501, 215, - 215, 215, 215, 215, 215, 215, 502, 215, - 215, 503, 215, 504, 505, 215, 215, 215, - 506, 507, 508, 509, 510, 511, 215, 215, - 215, 215, 215, 512, 215, 341, 215, 215, - 215, 215, 215, 215, 215, 215, 513, 514, - 215, 215, 215, 215, 215, 215, 215, 215, - 215, 215, 215, 215, 215, 215, 215, 215, - 215, 515, 516, 517, 518, 519, 520, 521, - 522, 523, 524, 524, 525, 525, 525, 525, - 525, 525, 525, 526, 526, 526, 526, 524, - 524, 524, 524, 524, 524, 524, 524, 524, - 524, 525, 525, 526, 526, 526, 526, 526, - 526, 527, 528, 529, 530, 531, 532, 526, - 526, 533, 534, 535, 536, 537, 526, 526, - 526, 526, 526, 526, 526, 524, 526, 525, - 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, - 526, 538, 539, 540, 541, 542, 543, 544, - 545, 546, 547, 548, 549, 550, 543, 543, - 551, 543, 552, 543, 553, 554, 555, 556, - 556, 556, 556, 555, 557, 556, 556, 556, - 556, 556, 558, 558, 559, 560, 561, 562, - 563, 564, 556, 556, 556, 556, 565, 566, - 556, 567, 568, 556, 556, 569, 569, 569, - 569, 570, 556, 556, 556, 556, 543, 543, - 543, 571, 572, 573, 574, 575, 576, 543, - 556, 556, 556, 543, 543, 543, 556, 556, - 577, 543, 543, 543, 556, 556, 556, 556, - 543, 555, 556, 556, 543, 578, 579, 579, - 578, 579, 579, 578, 543, 543, 543, 543, - 543, 543, 543, 543, 543, 543, 543, 543, - 543, 580, 581, 582, 583, 584, 526, 585, - 586, 0, 0, 587, 588, 589, 590, 591, - 592, 0, 0, 0, 0, 88, 593, 594, - 595, 596, 597, 598, 0, 599, 0, 600, - 601, 602, 603, 604, 605, 606, 607, 608, - 609, 610, 611, 612, 613, 614, 615, 616, - 617, 618, 619, 0, 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, + 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, 345, 345, 345, 345, 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, 345, 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, 594, 595, 595, 595, 595, + 595, 596, 597, 46, 46, 46, 46, 594, + 594, 594, 594, 594, 594, 594, 594, 594, + 594, 595, 595, 46, 46, 46, 46, 46, + 46, 598, 599, 600, 601, 602, 603, 46, + 46, 604, 605, 606, 607, 608, 46, 46, + 46, 46, 46, 46, 46, 594, 46, 595, + 46, 46, 46, 46, 46, 46, 46, 46, + 46, 46, 46, 46, 46, 46, 46, 46, + 46, 609, 610, 611, 612, 613, 614, 615, + 616, 617, 618, 619, 620, 621, 614, 614, + 622, 614, 623, 614, 624, 625, 626, 627, + 627, 627, 627, 626, 628, 627, 627, 627, + 627, 627, 629, 629, 630, 631, 632, 633, + 634, 635, 627, 627, 627, 627, 636, 637, + 627, 638, 639, 627, 627, 640, 640, 640, + 640, 641, 627, 627, 627, 627, 614, 614, + 614, 642, 643, 644, 645, 646, 647, 614, + 627, 627, 627, 614, 614, 614, 627, 627, + 648, 614, 614, 614, 627, 627, 627, 627, + 614, 626, 627, 627, 614, 649, 650, 650, + 649, 650, 650, 649, 614, 614, 614, 614, + 614, 614, 614, 614, 614, 614, 614, 614, + 614, 651, 652, 653, 654, 655, 46, 656, + 657, 0, 0, 658, 659, 660, 661, 662, + 663, 0, 0, 0, 0, 87, 664, 665, + 666, 667, 668, 669, 0, 670, 0, 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, 75, - 703, 704, 705, 706, 707, 215, 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, 756, 757, - 758, 759, 760, 761, 762, 763, 764, 765, - 766, 767, 768, 769, 770, 771, 772, 773, + 688, 689, 690, 0, 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, 756, 757, 758, + 759, 760, 761, 762, 763, 764, 765, 766, + 767, 768, 769, 770, 771, 772, 773, 74, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784, 785, 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796, 797, @@ -1898,17 +2269,17 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 814, 815, 816, 817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832, 833, 834, 835, 836, 837, - 838, 839, 840, 841, 543, 543, 543, 543, - 543, 842, 842, 843, 844, 845, 846, 847, - 848, 849, 850, 851, 852, 853, 854, 855, - 856, 857, 858, 859, 860, 861, 862, 863, - 864, 865, 866, 867, 868, 869, 870, 871, - 872, 873, 874, 875, 876, 877, 878, 879, - 880, 881, 882, 883, 884, 885, 886, 887, - 888, 889, 890, 891, 892, 893, 894, 895, - 896, 897, 898, 899, 900, 901, 902, 903, - 904, 905, 906, 907, 908, 909, 910, 911, - 912, 913, 914, 915, 916, 917, 918, 919, + 838, 839, 840, 841, 842, 843, 844, 845, + 846, 847, 848, 849, 850, 851, 852, 853, + 854, 855, 856, 857, 858, 859, 860, 861, + 862, 863, 864, 865, 866, 867, 868, 869, + 870, 871, 872, 873, 874, 875, 876, 877, + 878, 879, 880, 881, 882, 883, 884, 885, + 886, 887, 888, 889, 890, 891, 892, 893, + 894, 895, 896, 897, 898, 899, 900, 901, + 902, 903, 904, 905, 906, 907, 908, 909, + 910, 911, 912, 913, 614, 614, 614, 614, + 614, 914, 914, 915, 916, 917, 918, 919, 920, 921, 922, 923, 924, 925, 926, 927, 928, 929, 930, 931, 932, 933, 934, 935, 936, 937, 938, 939, 940, 941, 942, 943, @@ -1920,2614 +2291,2769 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 984, 985, 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, - 1008, 0, 1009, 1010, 1011, 1012, 1013, 1014, - 1015, 1016, 1017, 1018, 1019, 1020, 1021, 1022, - 1023, 1024, 1025, 1026, 1027, 1028, 1029, 1030, - 1031, 1032, 1033, 1034, 1035, 1036, 1037, 1038, - 1039, 1040, 1041, 1042, 1043, 1044, 1045, 1046, - 0, 0, 525, 1047, 1047, 1047, 1047, 1047, - 1047, 215, 1048, 1049, 1050, 1051, 1052, 1053, - 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, - 1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, - 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077, - 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, - 1086, 215, 1047, 1087, 0, 0, 77, 77, - 11, 0, 556, 543, 543, 543, 543, 556, - 543, 543, 543, 1088, 556, 543, 543, 543, - 543, 543, 543, 556, 556, 556, 556, 556, - 556, 543, 543, 556, 543, 543, 1088, 1089, - 543, 1090, 1091, 1092, 1093, 1094, 1095, 1096, - 1097, 1098, 1099, 1099, 1100, 1101, 1102, 1103, - 1104, 1105, 1106, 1107, 1105, 543, 556, 1105, - 1098, 0, 0, 0, 0, 0, 0, 0, - 0, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 0, 0, 0, 0, - 1108, 1108, 1108, 1108, 1105, 1105, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1109, 1109, 1109, 1109, 1109, 1109, 75, - 75, 1110, 10, 10, 1111, 15, 1112, 77, - 77, 543, 543, 543, 543, 543, 543, 543, - 543, 1113, 1114, 1115, 1112, 1116, 0, 1112, - 1112, 1117, 1117, 1118, 1119, 1120, 1121, 1122, - 1123, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1124, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1125, 1117, 1126, 1127, 1128, 1129, 1113, - 1114, 1115, 1130, 1131, 1132, 1133, 1134, 556, - 543, 543, 543, 543, 543, 556, 543, 543, - 556, 1135, 1135, 1135, 1135, 1135, 1135, 1135, - 1135, 1135, 1135, 10, 1136, 1136, 1112, 1117, - 1117, 1137, 1117, 1117, 1117, 1117, 1138, 1139, - 1140, 1141, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1142, 1143, 1144, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1145, 1146, 1112, 1147, 543, - 543, 543, 543, 543, 543, 543, 1109, 77, - 543, 543, 543, 543, 556, 543, 1124, 1124, - 543, 543, 77, 556, 543, 543, 556, 1117, - 1117, 17, 17, 17, 17, 17, 17, 17, - 17, 17, 17, 1117, 1117, 1117, 1148, 1148, - 1117, 1112, 1112, 1112, 1112, 1112, 1112, 1112, - 1112, 1112, 1112, 1112, 1112, 1112, 1112, 0, - 1149, 1117, 1150, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 543, 556, 543, 543, 556, 543, 543, - 556, 556, 556, 543, 556, 556, 543, 556, - 543, 543, 543, 556, 543, 556, 543, 556, - 543, 556, 543, 543, 0, 0, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1151, - 1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, - 1151, 1151, 1117, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1152, 1152, 1152, 1152, 1152, 1152, 1152, - 1152, 1152, 1152, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 543, 543, 543, 543, - 543, 543, 543, 556, 543, 1153, 1153, 77, - 9, 9, 9, 1153, 0, 0, 556, 1154, - 1154, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 543, - 543, 543, 543, 1153, 543, 543, 543, 543, - 543, 543, 543, 543, 543, 1153, 543, 543, - 543, 1153, 543, 543, 543, 543, 543, 0, - 0, 1105, 1105, 1105, 1105, 1105, 1105, 1105, - 1105, 1105, 1105, 1105, 1105, 1105, 1105, 1105, - 0, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 556, 556, 556, 0, 0, 1105, - 0, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 0, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 556, 543, 543, 543, - 543, 543, 543, 543, 543, 543, 543, 543, - 543, 543, 543, 1109, 556, 543, 543, 556, - 543, 543, 556, 543, 543, 543, 556, 556, - 556, 1127, 1128, 1129, 543, 543, 543, 556, - 543, 543, 556, 556, 543, 543, 543, 543, - 543, 1151, 1151, 1151, 1155, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 1156, 1157, 341, 341, 341, 341, 341, - 341, 1158, 1159, 341, 1160, 1161, 341, 341, - 341, 341, 341, 1151, 1155, 1162, 341, 1155, - 1155, 1155, 1151, 1151, 1151, 1151, 1151, 1151, - 1151, 1151, 1155, 1155, 1155, 1155, 1163, 1155, - 1155, 341, 543, 556, 543, 543, 1151, 1151, - 1151, 1164, 1165, 1166, 1167, 1168, 1169, 1170, - 1171, 341, 341, 1151, 1151, 1047, 1047, 1172, - 1172, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1047, 525, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 1151, 1155, 1155, 0, 341, 341, - 341, 341, 341, 341, 341, 341, 0, 0, - 341, 341, 0, 0, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 0, 341, 341, 341, 341, 341, - 341, 341, 0, 341, 0, 0, 0, 341, - 341, 341, 341, 0, 0, 1173, 341, 1174, - 1155, 1155, 1151, 1151, 1151, 1151, 0, 0, - 1175, 1155, 0, 0, 1176, 1177, 1163, 341, - 0, 0, 0, 0, 0, 0, 0, 0, - 1178, 0, 0, 0, 0, 1179, 1180, 0, - 1181, 341, 341, 1151, 1151, 0, 0, 1172, - 1172, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 341, 341, 11, 11, 1182, 1182, 1182, - 1182, 1182, 1182, 841, 11, 341, 1047, 543, - 0, 0, 1151, 1151, 1155, 0, 341, 341, - 341, 341, 341, 341, 0, 0, 0, 0, - 341, 341, 0, 0, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 0, 341, 341, 341, 341, 341, - 341, 341, 0, 341, 1183, 0, 341, 1184, - 0, 341, 341, 0, 0, 1173, 0, 1155, - 1155, 1155, 1151, 1151, 0, 0, 0, 0, - 1151, 1151, 0, 0, 1151, 1151, 1163, 0, - 0, 0, 1151, 0, 0, 0, 0, 0, - 0, 0, 1185, 1186, 1187, 341, 0, 1188, - 0, 0, 0, 0, 0, 0, 0, 1172, - 1172, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1151, 1151, 341, 341, 341, 1151, 1047, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1151, 1151, 1155, 0, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 0, - 341, 341, 341, 0, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 0, 341, 341, 341, 341, 341, - 341, 341, 0, 341, 341, 0, 341, 341, - 341, 341, 341, 0, 0, 1173, 341, 1155, - 1155, 1155, 1151, 1151, 1151, 1151, 1151, 0, - 1151, 1151, 1155, 0, 1155, 1155, 1163, 0, - 0, 341, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 1151, 1151, 0, 0, 1172, - 1172, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1047, 11, 0, 0, 0, 0, 0, - 0, 0, 341, 1151, 1151, 1151, 1151, 1151, - 1151, 0, 1151, 1155, 1155, 0, 341, 341, - 341, 341, 341, 341, 341, 341, 0, 0, - 341, 341, 0, 0, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 0, 341, 341, 341, 341, 341, - 341, 341, 0, 341, 341, 0, 341, 341, - 341, 341, 341, 0, 0, 1173, 341, 1189, - 1151, 1155, 1151, 1151, 1151, 1151, 0, 0, - 1190, 1191, 0, 0, 1192, 1193, 1163, 0, - 0, 0, 0, 0, 0, 0, 0, 1194, - 1195, 0, 0, 0, 0, 1196, 1197, 0, - 341, 341, 341, 1151, 1151, 0, 0, 1172, - 1172, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 841, 341, 1182, 1182, 1182, 1182, 1182, - 1182, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1151, 341, 0, 341, 341, - 341, 341, 341, 341, 0, 0, 0, 341, - 341, 341, 0, 1198, 341, 1199, 341, 0, - 0, 0, 341, 341, 0, 341, 0, 341, - 341, 0, 0, 0, 341, 341, 0, 0, - 0, 341, 341, 341, 0, 0, 0, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 0, 0, 0, 0, 1200, - 1155, 1151, 1155, 1155, 0, 0, 0, 1201, - 1202, 1155, 0, 1203, 1204, 1205, 1163, 0, - 0, 341, 0, 0, 0, 0, 0, 0, - 1206, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1172, - 1172, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1182, 1182, 1182, 77, 77, 77, 77, - 77, 77, 11, 77, 0, 0, 0, 0, - 0, 1151, 1155, 1155, 1155, 1151, 341, 341, - 341, 341, 341, 341, 341, 341, 0, 341, - 341, 341, 0, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 0, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 0, 0, 0, 341, 1151, - 1151, 1151, 1155, 1155, 1155, 1155, 0, 1207, - 1151, 1208, 0, 1151, 1151, 1151, 1163, 0, - 0, 0, 0, 0, 0, 0, 1209, 1210, - 0, 341, 341, 341, 0, 0, 0, 0, - 0, 341, 341, 1151, 1151, 0, 0, 1172, - 1172, 1172, 1172, 1172, 1172, 1172, 1172, 1172, + 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, + 1016, 1017, 1018, 1019, 1020, 1021, 1022, 1023, + 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031, + 1032, 1033, 1034, 1035, 1036, 1037, 1038, 1039, + 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, + 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, + 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, + 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, + 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, + 1080, 0, 1081, 1082, 1083, 1084, 1085, 1086, + 1087, 1088, 1089, 1090, 1091, 1092, 1093, 1094, + 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, + 1103, 1104, 1105, 1106, 1107, 1108, 1109, 1110, + 1111, 1112, 1113, 1114, 1115, 1116, 1117, 1118, + 0, 0, 595, 1119, 1119, 1119, 1119, 1119, + 1119, 1120, 1121, 1122, 1123, 1124, 1125, 1126, + 1127, 1128, 1129, 1130, 1131, 1132, 1133, 1134, + 1135, 1136, 1137, 1138, 1139, 1140, 1141, 1142, + 1143, 1144, 1145, 1146, 1147, 1148, 1149, 1150, + 1151, 1152, 1153, 1154, 1155, 1156, 1157, 1158, + 1159, 1160, 1119, 1161, 0, 0, 76, 76, + 10, 0, 627, 614, 614, 614, 614, 627, + 614, 614, 614, 1162, 627, 614, 614, 614, + 614, 614, 614, 627, 627, 627, 627, 627, + 627, 614, 614, 627, 614, 614, 1162, 1163, + 614, 1164, 1165, 1166, 1167, 1168, 1169, 1170, + 1171, 1172, 1173, 1173, 1174, 1175, 1176, 1177, + 1178, 1179, 1180, 1181, 1179, 614, 627, 1179, 1172, 0, 0, 0, 0, 0, 0, 0, - 1047, 1211, 1211, 1211, 1211, 1211, 1211, 1211, - 841, 341, 1151, 1155, 1155, 1047, 341, 341, - 341, 341, 341, 341, 341, 341, 0, 341, - 341, 341, 0, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 0, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 0, 341, 341, - 341, 341, 341, 0, 0, 1173, 341, 1155, - 1212, 1213, 1155, 1214, 1155, 1155, 0, 1215, - 1216, 1217, 0, 1218, 1219, 1151, 1163, 0, - 0, 0, 0, 0, 0, 0, 1220, 1221, - 0, 0, 0, 0, 0, 0, 0, 341, - 0, 341, 341, 1151, 1151, 0, 0, 1172, - 1172, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 0, 341, 341, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1151, 1151, 1155, 1155, 0, 341, 341, - 341, 341, 341, 341, 341, 341, 0, 341, - 341, 341, 0, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 1163, 1163, 341, 1222, - 1155, 1155, 1151, 1151, 1151, 1151, 0, 1223, - 1224, 1155, 0, 1225, 1226, 1227, 1163, 1228, - 841, 0, 0, 0, 0, 341, 341, 341, - 1229, 1182, 1182, 1182, 1182, 1182, 1182, 1182, - 341, 341, 341, 1151, 1151, 0, 0, 1172, - 1172, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1182, 1182, 1182, 1182, 1182, 1182, 1182, - 1182, 1182, 841, 341, 341, 341, 341, 341, - 341, 0, 0, 1155, 1155, 0, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 0, 0, 0, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 0, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 0, 341, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 0, 0, 0, 1230, 0, 0, 0, 0, - 1231, 1155, 1155, 1151, 1151, 1151, 0, 1151, - 0, 1155, 1232, 1233, 1155, 1234, 1235, 1236, - 1237, 0, 0, 0, 0, 0, 0, 1172, - 1172, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 0, 0, 1155, 1155, 1047, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 1151, 341, 1238, 1151, 1151, 1151, - 1151, 1239, 1239, 1163, 0, 0, 0, 0, - 11, 341, 341, 341, 341, 341, 341, 525, - 1151, 1240, 1240, 1240, 1240, 1151, 1151, 1151, - 1047, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 1047, 1047, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 341, 341, 0, 341, 0, 341, - 341, 341, 341, 341, 0, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 0, 341, 0, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 1151, 341, 1241, 1151, 1151, 1151, - 1151, 1242, 1242, 1163, 1151, 1151, 341, 0, - 0, 341, 341, 341, 341, 341, 0, 525, - 0, 1243, 1243, 1243, 1243, 1151, 1151, 0, - 0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 0, 0, 1244, 1245, 341, - 341, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 841, 841, 841, 1047, 1047, 1047, - 1047, 1047, 1047, 1047, 1047, 1246, 1047, 1047, - 1047, 1047, 1047, 1047, 841, 1047, 841, 841, - 841, 556, 556, 841, 841, 841, 841, 841, - 841, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 1182, 1182, 1182, 1182, 1182, - 1182, 1182, 1182, 1182, 1182, 841, 556, 841, - 556, 841, 1247, 12, 13, 12, 13, 1155, - 1155, 341, 341, 341, 1248, 341, 341, 341, - 341, 0, 341, 341, 341, 341, 1249, 341, - 341, 341, 341, 1250, 341, 341, 341, 341, - 1251, 341, 341, 341, 341, 1252, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 1253, 341, 341, 341, 0, 0, - 0, 0, 1254, 1255, 1256, 1257, 1258, 1259, - 1260, 1261, 1262, 1255, 1255, 1255, 1255, 1151, - 1155, 1255, 1263, 543, 543, 1163, 1047, 543, - 543, 341, 341, 341, 341, 341, 1151, 1151, - 1151, 1151, 1151, 1151, 1264, 1151, 1151, 1151, - 1151, 0, 1151, 1151, 1151, 1151, 1265, 1151, - 1151, 1151, 1151, 1266, 1151, 1151, 1151, 1151, - 1267, 1151, 1151, 1151, 1151, 1268, 1151, 1151, - 1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, - 1151, 1151, 1269, 1151, 1151, 1151, 0, 841, - 841, 841, 841, 841, 841, 841, 841, 556, - 841, 841, 841, 841, 841, 841, 0, 841, - 841, 1047, 1047, 1047, 1047, 1047, 841, 841, - 841, 841, 1047, 1047, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 1270, 1271, - 341, 341, 341, 341, 1272, 1272, 1151, 1273, - 1151, 1151, 1155, 1151, 1151, 1151, 1151, 1151, - 1173, 1272, 1163, 1163, 1155, 1155, 1151, 1151, - 341, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 1047, 1047, 1047, 1047, 1047, - 1047, 341, 341, 341, 341, 341, 341, 1155, - 1155, 1151, 1151, 341, 341, 341, 341, 1151, - 1151, 1151, 341, 1272, 1272, 1272, 341, 341, - 1272, 1272, 1272, 1272, 1272, 1272, 1272, 341, - 341, 341, 1151, 1151, 1151, 1151, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 1151, 1272, 1155, 1151, 1151, - 1272, 1272, 1272, 1272, 1272, 1272, 556, 341, - 1272, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 1272, 1272, 1272, 1151, 841, - 841, 1274, 1275, 1276, 1277, 1278, 1279, 1280, - 1281, 1282, 1283, 1284, 1285, 1286, 1287, 1288, - 1289, 1290, 1291, 1292, 1293, 1294, 1295, 1296, - 1297, 1298, 1299, 1300, 1301, 1302, 1303, 1304, - 1305, 1306, 1307, 1308, 1309, 1310, 1311, 0, - 1312, 0, 0, 0, 0, 0, 1313, 0, - 0, 1314, 1315, 1316, 1317, 1318, 1319, 1320, - 1321, 1322, 1323, 1324, 1325, 1326, 1327, 1328, - 1329, 1330, 1331, 1332, 1333, 1334, 1335, 1336, - 1337, 1338, 1339, 1340, 1341, 1342, 1343, 1344, - 1345, 1346, 1347, 1348, 1349, 1350, 1351, 1352, - 1353, 1354, 1355, 1356, 1047, 1357, 1358, 1359, - 1360, 1361, 1361, 1361, 1361, 1361, 1361, 1361, - 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, - 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, - 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, - 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, - 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, - 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, - 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, - 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, - 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, - 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, - 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, - 1362, 1363, 1364, 1364, 1364, 1364, 1364, 1364, - 1364, 1364, 1364, 1364, 1364, 1364, 1364, 1364, - 1364, 1364, 1364, 1364, 1364, 1364, 1364, 1364, - 1364, 1364, 1364, 1364, 1364, 1364, 1364, 1364, - 1364, 1364, 1364, 1364, 1364, 1364, 1364, 1364, - 1364, 1364, 1364, 1364, 1364, 1364, 1364, 1364, - 1364, 1364, 1364, 1364, 1364, 1364, 1364, 1364, - 1364, 1364, 1364, 1364, 1364, 1364, 1364, 1364, - 1364, 1364, 1364, 1364, 1364, 1364, 1364, 1364, - 1364, 1365, 1365, 1365, 1365, 1365, 1365, 1365, - 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, - 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, - 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, - 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, - 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, - 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, - 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, - 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, - 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, - 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, - 1365, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 0, 341, 341, 341, 341, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 0, 341, 0, 341, 341, 341, 341, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 0, 341, 341, 341, 341, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 0, 341, 341, 341, 341, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 0, 341, 0, 341, 341, 341, 341, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 0, 341, 341, 341, 341, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 0, 0, 543, 543, - 543, 1047, 1047, 1047, 1047, 1047, 1047, 1047, - 1047, 1047, 1182, 1182, 1182, 1182, 1182, 1182, + 0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, - 1182, 1182, 1182, 1182, 1182, 1182, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 77, 77, 77, 77, 77, 77, 77, - 77, 77, 77, 0, 0, 0, 0, 0, - 0, 1366, 1367, 1368, 1369, 1370, 1371, 1372, - 1373, 1374, 1375, 1376, 1377, 1378, 1379, 1380, - 1381, 1382, 1383, 1384, 1385, 1386, 1387, 1388, - 1389, 1390, 1391, 1392, 1393, 1394, 1395, 1396, - 1397, 1398, 1399, 1400, 1401, 1402, 1403, 1404, - 1405, 1406, 1407, 1408, 1409, 1410, 1411, 1412, - 1413, 1414, 1415, 1416, 1417, 1418, 1419, 1420, - 1421, 1422, 1423, 1424, 1425, 1426, 1427, 1428, - 1429, 1430, 1431, 1432, 1433, 1434, 1435, 1436, - 1437, 1438, 1439, 1440, 1441, 1442, 1443, 1444, - 1445, 1446, 1447, 1448, 1449, 1450, 1451, 0, - 0, 1452, 1453, 1454, 1455, 1456, 1457, 0, - 0, 1087, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 841, 1047, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 8, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 12, 13, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 1047, 1047, 1047, 1458, - 1458, 1458, 341, 341, 341, 341, 341, 341, - 341, 341, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 0, 341, - 341, 341, 341, 1151, 1151, 1163, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 1151, 1151, 1163, 1047, 1047, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 1151, 1151, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 0, 341, - 341, 341, 0, 1151, 1151, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 577, 577, 1155, - 1151, 1151, 1151, 1151, 1151, 1151, 1151, 1155, - 1155, 1155, 1155, 1155, 1155, 1155, 1155, 1151, - 1155, 1155, 1151, 1151, 1151, 1151, 1151, 1151, - 1151, 1151, 1151, 1163, 1151, 1047, 1047, 1047, - 525, 1047, 1047, 1047, 11, 341, 543, 0, - 0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 0, 0, 0, 0, 0, - 0, 1211, 1211, 1211, 1211, 1211, 1211, 1211, - 1211, 1211, 1211, 0, 0, 0, 0, 0, - 0, 9, 9, 9, 9, 9, 9, 1087, - 9, 9, 9, 9, 577, 577, 577, 1459, - 0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 525, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 1151, 1151, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 1089, 341, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 0, 1151, 1151, 1151, 1155, 1155, 1155, 1155, - 1151, 1151, 1155, 1155, 1155, 0, 0, 0, - 0, 1155, 1155, 1151, 1155, 1155, 1155, 1155, - 1155, 1155, 1088, 543, 556, 0, 0, 0, - 0, 77, 0, 0, 0, 9, 9, 1172, - 1172, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 0, - 0, 341, 341, 341, 341, 341, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 0, 0, 0, 0, 0, - 0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 1182, 0, 0, 0, 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, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 543, 556, 1155, 1155, 1151, 0, 0, 1047, - 1047, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 1155, 1151, - 1155, 1151, 1151, 1151, 1151, 1151, 1151, 1151, - 0, 1163, 1272, 1151, 1272, 1272, 1151, 1151, - 1151, 1151, 1151, 1151, 1151, 1151, 1155, 1155, - 1155, 1155, 1155, 1155, 1151, 1151, 543, 543, - 543, 543, 543, 543, 543, 543, 0, 0, - 556, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 0, 0, 0, 0, 0, - 0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 0, 0, 0, 0, 0, - 0, 1047, 1047, 1047, 1047, 1047, 1047, 1047, - 525, 1047, 1047, 1047, 1047, 1047, 1047, 0, - 0, 543, 543, 543, 543, 543, 556, 556, - 556, 556, 556, 556, 543, 543, 556, 842, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1151, 1151, 1151, 1151, 1155, 1460, 1461, - 1462, 1463, 1464, 1465, 1466, 1467, 1468, 1469, - 341, 341, 1470, 1471, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 1173, 1472, 1151, - 1151, 1151, 1151, 1473, 1474, 1475, 1476, 1477, - 1478, 1479, 1480, 1481, 1482, 1483, 341, 341, - 341, 341, 341, 341, 341, 0, 0, 0, - 0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 1047, 1047, 1047, 1047, 1047, - 1047, 1047, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 543, 556, 543, 543, - 543, 543, 543, 543, 543, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 0, 0, - 0, 1151, 1151, 1155, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 1155, 1151, 1151, 1151, 1151, 1155, - 1155, 1151, 1151, 1483, 1163, 1151, 1151, 341, - 341, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 1173, - 1155, 1151, 1151, 1155, 1155, 1155, 1151, 1155, - 1151, 1151, 1151, 1483, 1483, 0, 0, 0, - 0, 0, 0, 0, 0, 1047, 1047, 1047, - 1047, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 1155, 1155, 1155, - 1155, 1155, 1155, 1155, 1155, 1151, 1151, 1151, - 1151, 1151, 1151, 1151, 1151, 1155, 1155, 1151, - 1173, 0, 0, 0, 1047, 1047, 1047, 1047, - 1047, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 0, 0, 0, 341, 341, - 341, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 525, 525, 525, 525, 525, 525, 1047, - 1047, 1484, 1485, 1486, 1487, 1488, 1488, 1489, - 1490, 1491, 0, 0, 0, 0, 0, 0, - 0, 1492, 1493, 1494, 1495, 1496, 1497, 1498, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 0, 0, 0, 0, + 1182, 1182, 1182, 1182, 1179, 1179, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1183, 1183, 1183, 1183, 1183, 1183, 74, + 74, 1184, 9, 9, 1185, 14, 1186, 76, + 76, 614, 614, 614, 614, 614, 614, 614, + 614, 1187, 1188, 1189, 1186, 1190, 1186, 1186, + 1186, 1191, 1191, 1192, 1193, 1194, 1195, 1196, + 1197, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1198, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1199, 1191, 1200, 1201, 1202, 1203, 1187, + 1188, 1189, 1204, 1205, 1206, 1207, 1208, 627, + 614, 614, 614, 614, 614, 627, 614, 614, + 627, 1209, 1209, 1209, 1209, 1209, 1209, 1209, + 1209, 1209, 1209, 9, 1210, 1210, 1186, 1191, + 1191, 1211, 1191, 1191, 1191, 1191, 1212, 1213, + 1214, 1215, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1216, 1217, 1218, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1219, 1220, 1186, 1221, 614, + 614, 614, 614, 614, 614, 614, 1183, 76, + 614, 614, 614, 614, 627, 614, 1198, 1198, + 614, 614, 76, 627, 614, 614, 627, 1191, + 1191, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 1191, 1191, 1191, 1222, 1222, + 1191, 1186, 1186, 1186, 1186, 1186, 1186, 1186, + 1186, 1186, 1186, 1186, 1186, 1186, 1186, 0, + 1223, 1191, 1224, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 614, 627, 614, 614, 627, 614, 614, + 627, 627, 627, 614, 627, 627, 614, 627, + 614, 614, 614, 627, 614, 627, 614, 627, + 614, 627, 614, 614, 0, 0, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1225, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 1225, 1191, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1226, 1226, 1226, 1226, 1226, 1226, 1226, + 1226, 1226, 1226, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 614, 614, 614, 614, + 614, 614, 614, 627, 614, 1227, 1227, 76, + 8, 8, 8, 1227, 0, 0, 627, 1228, + 1228, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 614, + 614, 614, 614, 1227, 614, 614, 614, 614, + 614, 614, 614, 614, 614, 1227, 614, 614, + 614, 1227, 614, 614, 614, 614, 614, 0, + 0, 1179, 1179, 1179, 1179, 1179, 1179, 1179, + 1179, 1179, 1179, 1179, 1179, 1179, 1179, 1179, + 0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 627, 627, 627, 0, 0, 1179, + 0, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 0, 0, 0, 0, + 0, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1229, 1191, 1191, 1191, 1191, 1191, 1191, + 0, 1183, 1183, 0, 0, 0, 0, 0, + 0, 614, 627, 627, 627, 614, 614, 614, + 614, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1198, 614, 614, 614, 614, 614, + 627, 627, 627, 627, 627, 614, 614, 614, + 614, 614, 614, 614, 614, 614, 614, 614, + 614, 614, 614, 1183, 627, 614, 614, 627, + 614, 614, 627, 614, 614, 614, 627, 627, + 627, 1201, 1202, 1203, 614, 614, 614, 627, + 614, 614, 627, 627, 614, 614, 614, 614, + 614, 1225, 1225, 1225, 1230, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 1231, 1231, + 1231, 1231, 1231, 1231, 1231, 1231, 1231, 1231, + 1231, 1231, 1231, 1231, 1231, 1231, 1231, 1231, + 1231, 1232, 1233, 1231, 1231, 1231, 1231, 1231, + 1231, 1234, 1235, 1231, 1236, 1237, 1231, 1231, + 1231, 1231, 1231, 1225, 1230, 1238, 345, 1230, + 1230, 1230, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 1225, 1230, 1230, 1230, 1230, 1239, 1230, + 1230, 345, 614, 627, 614, 614, 1225, 1225, + 1225, 1240, 1241, 1242, 1243, 1244, 1245, 1246, + 1247, 345, 345, 1225, 1225, 1119, 1119, 1248, + 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1119, 595, 345, 345, 345, 345, 345, + 345, 1231, 1231, 1231, 1231, 1231, 1231, 1231, + 1231, 345, 1225, 1230, 1230, 0, 345, 345, + 345, 345, 345, 345, 345, 345, 0, 0, + 345, 345, 0, 0, 345, 345, 1231, 1231, + 1231, 1231, 1231, 1231, 1231, 1231, 1231, 1231, + 1231, 1231, 1231, 1231, 1231, 1231, 1231, 1231, + 1231, 1231, 0, 1231, 1231, 1231, 1231, 1231, + 1231, 1231, 0, 1231, 0, 0, 0, 1231, + 1231, 1231, 1231, 0, 0, 1249, 345, 1250, + 1230, 1230, 1225, 1225, 1225, 1225, 0, 0, + 1251, 1230, 0, 0, 1252, 1253, 1239, 345, + 0, 0, 0, 0, 0, 0, 0, 0, + 1254, 0, 0, 0, 0, 1255, 1256, 0, + 1257, 345, 345, 1225, 1225, 0, 0, 1248, + 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1231, 1231, 10, 10, 1258, 1258, 1258, + 1258, 1258, 1258, 913, 10, 345, 1119, 614, + 0, 0, 1225, 1225, 1230, 0, 345, 345, + 345, 345, 345, 345, 0, 0, 0, 0, + 345, 345, 0, 0, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 0, 345, 345, 345, 345, 345, + 345, 345, 0, 345, 1259, 0, 345, 1260, + 0, 345, 345, 0, 0, 1249, 0, 1230, + 1230, 1230, 1225, 1225, 0, 0, 0, 0, + 1225, 1225, 0, 0, 1225, 1225, 1261, 0, + 0, 0, 1225, 0, 0, 0, 0, 0, + 0, 0, 1262, 1263, 1264, 345, 0, 1265, + 0, 0, 0, 0, 0, 0, 0, 1248, + 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1225, 1225, 345, 345, 345, 1225, 1119, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1225, 1225, 1230, 0, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 0, + 345, 345, 345, 0, 345, 345, 1231, 1231, + 1231, 1231, 1231, 1231, 1231, 1231, 1231, 1231, + 1231, 1231, 1231, 1231, 1231, 1231, 1231, 1231, + 1231, 1231, 0, 1231, 1231, 1231, 1231, 1231, + 1231, 1231, 0, 1231, 1231, 0, 1231, 1231, + 1231, 1231, 1231, 0, 0, 1249, 345, 1230, + 1230, 1230, 1225, 1225, 1225, 1225, 1225, 0, + 1225, 1225, 1230, 0, 1230, 1230, 1239, 0, + 0, 345, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 1225, 1225, 0, 0, 1248, + 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1119, 10, 0, 0, 0, 0, 0, + 0, 0, 1231, 1225, 1225, 1225, 1225, 1225, + 1225, 0, 1225, 1230, 1230, 0, 345, 345, + 345, 345, 345, 345, 345, 345, 0, 0, + 345, 345, 0, 0, 345, 345, 1231, 1231, + 1231, 1231, 1231, 1231, 1231, 1231, 1231, 1231, + 1231, 1231, 1231, 1231, 1231, 1231, 1231, 1231, + 1231, 1231, 0, 1231, 1231, 1231, 1231, 1231, + 1231, 1231, 0, 1231, 1231, 0, 1231, 1231, + 1231, 1231, 1231, 0, 0, 1249, 345, 1266, + 1225, 1230, 1225, 1225, 1225, 1225, 0, 0, + 1267, 1268, 0, 0, 1269, 1270, 1239, 0, + 0, 0, 0, 0, 0, 0, 1225, 1271, + 1272, 0, 0, 0, 0, 1273, 1274, 0, + 1231, 345, 345, 1225, 1225, 0, 0, 1248, + 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 913, 1231, 1258, 1258, 1258, 1258, 1258, + 1258, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1225, 345, 0, 345, 345, + 345, 345, 345, 345, 0, 0, 0, 345, + 345, 345, 0, 1275, 345, 1276, 345, 0, + 0, 0, 345, 345, 0, 345, 0, 345, + 345, 0, 0, 0, 345, 345, 0, 0, + 0, 345, 345, 345, 0, 0, 0, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 0, 0, 0, 0, 1277, + 1230, 1225, 1230, 1230, 0, 0, 0, 1278, + 1279, 1230, 0, 1280, 1281, 1282, 1261, 0, + 0, 345, 0, 0, 0, 0, 0, 0, + 1283, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1248, + 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1258, 1258, 1258, 76, 76, 76, 76, + 76, 76, 10, 76, 0, 0, 0, 0, + 0, 1225, 1230, 1230, 1230, 1225, 345, 345, + 345, 345, 345, 345, 345, 345, 0, 345, + 345, 345, 0, 345, 345, 345, 1231, 1231, + 1231, 1231, 1231, 1231, 1231, 1231, 1231, 1231, + 1231, 1231, 1231, 1231, 1231, 1231, 1231, 1231, + 1231, 1231, 0, 1231, 1231, 1231, 1231, 1231, + 1231, 1231, 1231, 1231, 1231, 1231, 1231, 1231, + 1231, 1231, 1231, 0, 0, 1249, 345, 1225, + 1225, 1225, 1230, 1230, 1230, 1230, 0, 1284, + 1225, 1285, 0, 1225, 1225, 1225, 1239, 0, + 0, 0, 0, 0, 0, 0, 1286, 1287, + 0, 1231, 1231, 1231, 0, 0, 345, 0, + 0, 345, 345, 1225, 1225, 0, 0, 1248, + 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 0, 0, 0, 0, 0, 0, 0, + 1119, 1288, 1288, 1288, 1288, 1288, 1288, 1288, + 913, 345, 1225, 1230, 1230, 1119, 345, 345, + 345, 345, 345, 345, 345, 345, 0, 345, + 345, 345, 0, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 0, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 0, 345, 345, + 345, 345, 345, 0, 0, 1249, 345, 1230, + 1289, 1290, 1230, 1291, 1230, 1230, 0, 1292, + 1293, 1294, 0, 1295, 1296, 1225, 1261, 0, + 0, 0, 0, 0, 0, 0, 1297, 1298, + 0, 0, 0, 0, 0, 0, 345, 345, + 0, 345, 345, 1225, 1225, 0, 0, 1248, + 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 0, 345, 345, 1230, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1225, 1225, 1230, 1230, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 0, 345, + 345, 345, 0, 345, 345, 345, 1231, 1231, + 1231, 1231, 1231, 1231, 1231, 1231, 1231, 1231, + 1231, 1231, 1231, 1231, 1231, 1231, 1231, 1231, + 1231, 1231, 1231, 1231, 1231, 1231, 1231, 1231, + 1231, 1231, 1231, 1231, 1231, 1231, 1231, 1231, + 1231, 1231, 1231, 1231, 1299, 1299, 345, 1300, + 1230, 1230, 1225, 1225, 1225, 1225, 0, 1301, + 1302, 1230, 0, 1303, 1304, 1305, 1239, 1306, + 913, 0, 0, 0, 0, 345, 345, 345, + 1307, 1258, 1258, 1258, 1258, 1258, 1258, 1258, + 345, 345, 345, 1225, 1225, 0, 0, 1248, + 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1258, 1258, 1258, 1258, 1258, 1258, 1258, + 1258, 1258, 913, 345, 345, 345, 345, 345, + 345, 0, 1225, 1230, 1230, 0, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 0, 0, 0, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 0, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 0, 345, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 0, 0, 0, 1308, 0, 0, 0, 0, + 1309, 1230, 1230, 1225, 1225, 1225, 0, 1225, + 0, 1230, 1310, 1311, 1230, 1312, 1313, 1314, + 1315, 0, 0, 0, 0, 0, 0, 1248, + 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 0, 0, 1230, 1230, 1119, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 1225, 345, 1316, 1225, 1225, 1225, + 1225, 1317, 1317, 1299, 0, 0, 0, 0, + 10, 345, 345, 345, 345, 345, 345, 595, + 1225, 1318, 1318, 1318, 1318, 1225, 1225, 1225, + 1119, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 1119, 1119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 345, 345, 0, 345, 0, 345, + 345, 345, 345, 345, 0, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 0, 345, 0, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 1225, 345, 1319, 1225, 1225, 1225, + 1225, 1320, 1320, 1299, 1225, 1225, 345, 0, + 0, 345, 345, 345, 345, 345, 0, 595, + 0, 1321, 1321, 1321, 1321, 1225, 1225, 1225, + 0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 0, 0, 1322, 1323, 345, + 345, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 913, 913, 913, 1119, 1119, 1119, + 1119, 1119, 1119, 1119, 1119, 1324, 1119, 1119, + 1119, 1119, 1119, 1119, 913, 1119, 913, 913, + 913, 627, 627, 913, 913, 913, 913, 913, + 913, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 1258, 1258, 1258, 1258, 1258, + 1258, 1258, 1258, 1258, 1258, 913, 627, 913, + 627, 913, 1325, 11, 12, 11, 12, 1230, + 1230, 345, 345, 345, 1326, 345, 345, 345, + 345, 0, 345, 345, 345, 345, 1327, 345, + 345, 345, 345, 1328, 345, 345, 345, 345, + 1329, 345, 345, 345, 345, 1330, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 1331, 345, 345, 345, 0, 0, + 0, 0, 1332, 1333, 1334, 1335, 1336, 1337, + 1338, 1339, 1340, 1333, 1333, 1333, 1333, 1225, + 1230, 1333, 1341, 614, 614, 1299, 1119, 614, + 614, 345, 345, 345, 345, 345, 1225, 1225, + 1225, 1225, 1225, 1225, 1342, 1225, 1225, 1225, + 1225, 0, 1225, 1225, 1225, 1225, 1343, 1225, + 1225, 1225, 1225, 1344, 1225, 1225, 1225, 1225, + 1345, 1225, 1225, 1225, 1225, 1346, 1225, 1225, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 1225, 1347, 1225, 1225, 1225, 0, 913, + 913, 913, 913, 913, 913, 913, 913, 627, + 913, 913, 913, 913, 913, 913, 0, 913, + 913, 1119, 1119, 1119, 1119, 1119, 913, 913, + 913, 913, 1119, 1119, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 1348, 1349, + 345, 345, 345, 345, 1350, 1350, 1225, 1351, + 1225, 1225, 1230, 1225, 1225, 1225, 1225, 1225, + 1249, 1350, 1299, 1299, 1230, 1230, 1225, 1225, + 345, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 1119, 1119, 1119, 1119, 1119, + 1119, 345, 345, 345, 345, 345, 345, 1230, + 1230, 1225, 1225, 345, 345, 345, 345, 1225, + 1225, 1225, 345, 1350, 1350, 1350, 345, 345, + 1350, 1350, 1350, 1350, 1350, 1350, 1350, 345, + 345, 345, 1225, 1225, 1225, 1225, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 1225, 1350, 1230, 1225, 1225, + 1350, 1350, 1350, 1350, 1350, 1350, 627, 345, + 1350, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 1350, 1350, 1350, 1225, 913, + 913, 1352, 1353, 1354, 1355, 1356, 1357, 1358, + 1359, 1360, 1361, 1362, 1363, 1364, 1365, 1366, + 1367, 1368, 1369, 1370, 1371, 1372, 1373, 1374, + 1375, 1376, 1377, 1378, 1379, 1380, 1381, 1382, + 1383, 1384, 1385, 1386, 1387, 1388, 1389, 0, + 1390, 0, 0, 0, 0, 0, 1391, 0, + 0, 1392, 1393, 1394, 1395, 1396, 1397, 1398, + 1399, 1400, 1401, 1402, 1403, 1404, 1405, 1406, + 1407, 1408, 1409, 1410, 1411, 1412, 1413, 1414, + 1415, 1416, 1417, 1418, 1419, 1420, 1421, 1422, + 1423, 1424, 1425, 1426, 1427, 1428, 1429, 1430, + 1431, 1432, 1433, 1434, 1119, 1435, 1436, 1437, + 1438, 1439, 1439, 1439, 1439, 1439, 1439, 1439, + 1439, 1439, 1439, 1439, 1439, 1439, 1439, 1439, + 1439, 1439, 1439, 1439, 1439, 1439, 1439, 1439, + 1439, 1439, 1439, 1439, 1439, 1439, 1439, 1439, + 1439, 1439, 1439, 1439, 1439, 1439, 1439, 1439, + 1439, 1439, 1439, 1439, 1439, 1439, 1439, 1439, + 1439, 1439, 1439, 1439, 1439, 1439, 1439, 1439, + 1439, 1439, 1439, 1439, 1439, 1439, 1439, 1439, + 1439, 1439, 1439, 1439, 1439, 1439, 1439, 1439, + 1439, 1439, 1439, 1439, 1439, 1439, 1439, 1439, + 1439, 1439, 1439, 1439, 1439, 1439, 1439, 1439, + 1439, 1439, 1439, 1439, 1439, 1439, 1439, 1439, + 1440, 1441, 1442, 1442, 1442, 1442, 1442, 1442, + 1442, 1442, 1442, 1442, 1442, 1442, 1442, 1442, + 1442, 1442, 1442, 1442, 1442, 1442, 1442, 1442, + 1442, 1442, 1442, 1442, 1442, 1442, 1442, 1442, + 1442, 1442, 1442, 1442, 1442, 1442, 1442, 1442, + 1442, 1442, 1442, 1442, 1442, 1442, 1442, 1442, + 1442, 1442, 1442, 1442, 1442, 1442, 1442, 1442, + 1442, 1442, 1442, 1442, 1442, 1442, 1442, 1442, + 1442, 1442, 1442, 1442, 1442, 1442, 1442, 1442, + 1442, 1443, 1443, 1443, 1443, 1443, 1443, 1443, + 1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, + 1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, + 1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, + 1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, + 1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, + 1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, + 1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, + 1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, + 1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, + 1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, + 1443, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 0, 345, 345, 345, 345, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 0, 345, 0, 345, 345, 345, 345, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 0, 345, 345, 345, 345, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 0, 345, 345, 345, 345, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 0, 345, 0, 345, 345, 345, 345, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 0, 345, 345, 345, 345, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 0, 0, 614, 614, + 614, 1119, 1119, 1119, 1119, 1119, 1119, 1119, + 1119, 1119, 1258, 1258, 1258, 1258, 1258, 1258, + 1258, 1258, 1258, 1258, 1258, 1258, 1258, 1258, + 1258, 1258, 1258, 1258, 1258, 1258, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 76, 76, 76, 76, 76, 76, 76, + 76, 76, 76, 0, 0, 0, 0, 0, + 0, 1444, 1445, 1446, 1447, 1448, 1449, 1450, + 1451, 1452, 1453, 1454, 1455, 1456, 1457, 1458, + 1459, 1460, 1461, 1462, 1463, 1464, 1465, 1466, + 1467, 1468, 1469, 1470, 1471, 1472, 1473, 1474, + 1475, 1476, 1477, 1478, 1479, 1480, 1481, 1482, + 1483, 1484, 1485, 1486, 1487, 1488, 1489, 1490, + 1491, 1492, 1493, 1494, 1495, 1496, 1497, 1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513, 1514, 1515, 1516, 1517, 1518, 1519, 1520, 1521, 1522, - 1523, 1524, 1525, 1526, 1527, 1528, 1529, 1530, - 1531, 1532, 1533, 1534, 0, 0, 1535, 1536, - 1537, 1047, 1047, 1047, 1047, 1047, 1047, 1047, - 1047, 0, 0, 0, 0, 0, 0, 0, - 0, 543, 543, 543, 1047, 569, 556, 556, - 556, 556, 556, 543, 543, 556, 556, 556, - 556, 543, 1155, 569, 569, 569, 569, 569, - 569, 569, 341, 341, 341, 341, 556, 341, - 341, 341, 341, 341, 341, 543, 341, 341, - 1155, 543, 543, 341, 0, 0, 0, 0, - 0, 215, 215, 215, 215, 215, 215, 215, - 215, 215, 215, 215, 215, 215, 215, 215, - 215, 215, 215, 215, 215, 215, 215, 215, - 215, 215, 215, 215, 215, 215, 215, 215, - 215, 215, 215, 215, 215, 215, 215, 215, - 215, 215, 215, 215, 215, 1538, 1539, 1540, - 525, 1541, 1542, 1543, 1544, 1545, 1546, 1547, - 1548, 1549, 1550, 1551, 525, 1552, 1553, 1554, - 1555, 1556, 1557, 1558, 1559, 1560, 1561, 1562, - 1563, 1564, 1565, 1566, 1567, 1568, 1569, 525, - 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, - 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, - 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, - 1594, 1595, 1596, 1597, 215, 215, 215, 215, - 215, 215, 215, 215, 215, 215, 215, 215, - 215, 1598, 1599, 215, 215, 215, 1600, 215, - 215, 215, 215, 215, 215, 215, 215, 215, - 215, 215, 215, 215, 215, 215, 215, 1601, - 215, 215, 215, 215, 215, 215, 215, 215, - 215, 215, 215, 215, 1602, 1603, 1604, 1605, - 1568, 1606, 1607, 1608, 1609, 1610, 1611, 1612, - 1613, 1614, 1615, 1616, 1617, 1618, 1619, 1620, - 1621, 1622, 1623, 1624, 1625, 1626, 1627, 1628, - 1629, 1630, 1631, 1632, 1633, 1634, 1635, 1636, - 1637, 543, 543, 556, 543, 543, 543, 543, - 543, 543, 543, 556, 543, 543, 579, 1638, - 556, 558, 543, 543, 543, 543, 543, 543, - 543, 543, 543, 543, 543, 543, 543, 543, - 543, 543, 543, 543, 543, 543, 543, 543, - 543, 543, 543, 543, 543, 543, 543, 543, - 543, 543, 543, 543, 543, 543, 543, 555, - 1089, 1089, 556, 0, 543, 578, 556, 543, - 556, 1639, 1640, 1641, 1642, 1643, 1644, 1645, - 1646, 1647, 1648, 1649, 1650, 1651, 1652, 1653, - 1654, 1655, 1656, 1657, 1658, 1659, 1660, 1661, - 1662, 1663, 1664, 1665, 1666, 1667, 1668, 1669, - 1670, 1671, 1672, 1673, 1674, 1675, 1676, 1677, - 1678, 1679, 1680, 1681, 1682, 1683, 1684, 1685, - 1686, 1687, 1688, 1689, 1690, 1691, 1692, 1693, - 1694, 1695, 1696, 1697, 1698, 1699, 1700, 1701, - 1702, 1703, 1704, 1705, 1706, 1707, 1708, 1709, - 1710, 1711, 1712, 1713, 1714, 1715, 1716, 1717, - 1718, 1719, 1720, 1721, 1722, 1723, 1724, 1725, - 1726, 1727, 1728, 1729, 1730, 1731, 1732, 1733, - 1734, 1735, 1736, 1737, 1738, 1739, 1740, 1741, - 1742, 1743, 1744, 1745, 1746, 1747, 1748, 1749, - 1750, 1751, 1752, 1753, 1754, 1755, 1756, 1757, - 1758, 1759, 1760, 1761, 1762, 1763, 1764, 1765, - 1766, 1767, 1768, 1769, 1770, 1771, 1772, 1773, - 1774, 1775, 1776, 1777, 1778, 1779, 1780, 1781, - 1782, 1783, 1784, 1785, 1786, 1787, 1788, 1789, - 1790, 1791, 1792, 1793, 1794, 215, 215, 1795, - 215, 1796, 1797, 1798, 1799, 1800, 1801, 1802, - 1803, 1804, 1805, 1806, 1807, 1808, 1809, 1810, - 1811, 1812, 1813, 1814, 1815, 1816, 1817, 1818, - 1819, 1820, 1821, 1822, 1823, 1824, 1825, 1826, - 1827, 1828, 1829, 1830, 1831, 1832, 1833, 1834, - 1835, 1836, 1837, 1838, 1839, 1840, 1841, 1842, - 1843, 1844, 1845, 1846, 1847, 1848, 1849, 1850, - 1851, 1852, 1853, 1854, 1855, 1856, 1857, 1858, - 1859, 1860, 1861, 1862, 1863, 1864, 1865, 1866, - 1867, 1868, 1869, 1870, 1871, 1872, 1873, 1874, - 1875, 1876, 1877, 1878, 1879, 1880, 1881, 1882, - 1883, 1884, 1885, 1886, 1887, 1888, 1889, 1890, - 1891, 1892, 1893, 1894, 1895, 1896, 1897, 1898, - 1899, 1900, 1901, 1902, 1903, 1904, 1905, 1906, - 1907, 1908, 1909, 1910, 1911, 1912, 1913, 0, - 0, 1914, 1915, 1916, 1917, 1918, 1919, 0, - 0, 1920, 1921, 1922, 1923, 1924, 1925, 1926, - 1927, 1928, 1929, 1930, 1931, 1932, 1933, 1934, - 1935, 1936, 1937, 1938, 1939, 1940, 1941, 1942, - 1943, 1944, 1945, 1946, 1947, 1948, 1949, 1950, - 1951, 1952, 1953, 1954, 1955, 1956, 1957, 0, - 0, 1958, 1959, 1960, 1961, 1962, 1963, 0, - 0, 1964, 1965, 1966, 1967, 1968, 1969, 1970, - 1971, 0, 1972, 0, 1973, 0, 1974, 0, - 1975, 1976, 1977, 1978, 1979, 1980, 1981, 1982, - 1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, - 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, - 1999, 2000, 2001, 2002, 2003, 2004, 2005, 0, - 0, 2006, 2007, 2008, 2009, 2010, 2011, 2012, - 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, - 2021, 2022, 2023, 2024, 2025, 2026, 2027, 2028, - 2029, 2030, 2031, 2032, 2033, 2034, 2035, 2036, - 2037, 2038, 2039, 2040, 2041, 2042, 2043, 2044, - 2045, 2046, 2047, 2048, 2049, 2050, 2051, 2052, - 2053, 2054, 2055, 2056, 2057, 2058, 0, 2059, - 2060, 2061, 2062, 2063, 2064, 2065, 2066, 2067, - 2068, 2069, 2070, 2071, 2072, 2073, 0, 2074, - 2075, 2076, 2077, 2078, 2079, 2080, 2081, 2082, - 2083, 2084, 2085, 2086, 2087, 0, 0, 2088, - 2089, 2090, 2091, 2092, 2093, 0, 2094, 2095, - 2096, 2097, 2098, 2099, 2100, 2101, 2102, 2103, - 2104, 2105, 2106, 2107, 2108, 2109, 2110, 2111, - 2112, 0, 0, 2113, 2114, 2115, 0, 2116, + 1523, 1524, 1525, 1526, 1527, 1528, 1529, 0, + 0, 1530, 1531, 1532, 1533, 1534, 1535, 0, + 0, 1161, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 913, 1119, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 7, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 11, 12, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 1119, 1119, 1119, 1536, + 1536, 1536, 345, 345, 345, 345, 345, 345, + 345, 345, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 1225, 1225, 1299, 1537, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 1225, 1225, 1537, 1119, 1119, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 1225, 1225, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 0, 345, + 345, 345, 0, 1225, 1225, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 648, 648, 1230, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1230, + 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1225, + 1230, 1230, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 1225, 1225, 1299, 1225, 1119, 1119, 1119, + 595, 1119, 1119, 1119, 10, 345, 614, 0, + 0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 0, 0, 0, 0, 0, + 0, 1288, 1288, 1288, 1288, 1288, 1288, 1288, + 1288, 1288, 1288, 0, 0, 0, 0, 0, + 0, 8, 8, 8, 8, 8, 8, 1161, + 8, 8, 8, 8, 648, 648, 648, 1538, + 648, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 595, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 1225, 1225, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 1163, 345, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 0, 1225, 1225, 1225, 1230, 1230, 1230, 1230, + 1225, 1225, 1230, 1230, 1230, 0, 0, 0, + 0, 1230, 1230, 1225, 1230, 1230, 1230, 1230, + 1230, 1230, 1162, 614, 627, 0, 0, 0, + 0, 76, 0, 0, 0, 8, 8, 1248, + 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 0, + 0, 345, 345, 345, 345, 345, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 0, 0, 0, 0, 0, + 0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 1258, 0, 0, 0, 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, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 614, 627, 1230, 1230, 1225, 0, 0, 1119, + 1119, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 1230, 1225, + 1230, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 0, 1299, 1350, 1225, 1350, 1350, 1225, 1225, + 1225, 1225, 1225, 1225, 1225, 1225, 1230, 1230, + 1230, 1230, 1230, 1230, 1225, 1225, 614, 614, + 614, 614, 614, 614, 614, 614, 0, 0, + 627, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 0, 0, 0, 0, 0, + 0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 0, 0, 0, 0, 0, + 0, 1119, 1119, 1119, 1119, 1119, 1119, 1119, + 595, 1119, 1119, 1119, 1119, 1119, 1119, 0, + 0, 614, 614, 614, 614, 614, 627, 627, + 627, 627, 627, 627, 614, 614, 627, 914, + 627, 627, 614, 614, 627, 627, 614, 614, + 614, 614, 614, 627, 614, 614, 614, 614, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1225, 1225, 1225, 1225, 1230, 1539, 1540, + 1541, 1542, 1543, 1544, 1545, 1546, 1547, 1548, + 345, 345, 1549, 1550, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 1249, 1551, 1225, + 1225, 1225, 1225, 1552, 1553, 1554, 1555, 1556, + 1557, 1558, 1559, 1560, 1561, 1537, 345, 345, + 345, 345, 345, 345, 345, 345, 0, 0, + 0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 1119, 1119, 1119, 1119, 1119, + 1119, 1119, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 614, 627, 614, 614, + 614, 614, 614, 614, 614, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 1119, 1119, + 0, 1225, 1225, 1230, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 1230, 1225, 1225, 1225, 1225, 1230, + 1230, 1225, 1225, 1537, 1299, 1225, 1225, 345, + 345, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 1249, + 1230, 1225, 1225, 1230, 1230, 1230, 1225, 1230, + 1225, 1225, 1225, 1537, 1537, 0, 0, 0, + 0, 0, 0, 0, 0, 1119, 1119, 1119, + 1119, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 1230, 1230, 1230, + 1230, 1230, 1230, 1230, 1230, 1225, 1225, 1225, + 1225, 1225, 1225, 1225, 1225, 1230, 1230, 1225, + 1249, 0, 0, 0, 1119, 1119, 1119, 1119, + 1119, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 0, 0, 0, 345, 345, + 345, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 595, 595, 595, 595, 595, 595, 1119, + 1119, 1562, 1563, 1564, 1565, 1566, 1566, 1567, + 1568, 1569, 0, 0, 0, 0, 0, 0, + 0, 1570, 1571, 1572, 1573, 1574, 1575, 1576, + 1577, 1578, 1579, 1580, 1581, 1582, 1583, 1584, + 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, + 1593, 1594, 1595, 1596, 1597, 1598, 1599, 1600, + 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, + 1609, 1610, 1611, 1612, 0, 0, 1613, 1614, + 1615, 1119, 1119, 1119, 1119, 1119, 1119, 1119, + 1119, 0, 0, 0, 0, 0, 0, 0, + 0, 614, 614, 614, 1119, 640, 627, 627, + 627, 627, 627, 614, 614, 627, 627, 627, + 627, 614, 1230, 640, 640, 640, 640, 640, + 640, 640, 345, 345, 345, 345, 627, 345, + 345, 345, 345, 345, 345, 614, 345, 345, + 1230, 614, 614, 345, 0, 0, 0, 0, + 0, 1616, 1617, 1618, 1619, 1620, 1621, 1622, + 1623, 1624, 1625, 1626, 1627, 1628, 1629, 1630, + 1631, 1632, 1633, 1634, 1635, 1636, 1637, 1638, + 1639, 1640, 1641, 1642, 1643, 1644, 1645, 1646, + 1647, 1648, 1649, 1650, 1651, 1652, 1653, 1654, + 1655, 1656, 1657, 1658, 1659, 1660, 1661, 1662, + 1663, 1664, 1665, 1666, 1667, 1668, 1669, 1670, + 1671, 1672, 1673, 1674, 1675, 1676, 1677, 1678, + 1679, 1680, 1681, 1682, 1683, 1684, 1685, 1686, + 1687, 1688, 1689, 1690, 1691, 1692, 1693, 1694, + 1695, 1696, 1697, 1698, 1699, 1700, 1701, 1702, + 1703, 1704, 1705, 1706, 1707, 1708, 1709, 1710, + 1711, 1712, 1713, 1714, 1715, 1716, 1717, 1718, + 1719, 1720, 1721, 1722, 1723, 1724, 1725, 1726, + 1727, 1728, 1729, 1730, 1731, 1732, 1733, 1734, + 1735, 1736, 1737, 1738, 1739, 1740, 1741, 1742, + 1743, 1744, 1745, 1746, 1747, 1748, 1749, 1750, + 1751, 1752, 1753, 1754, 1755, 1756, 1757, 1758, + 1759, 1760, 1761, 1762, 1763, 1764, 1765, 1766, + 1767, 1768, 1769, 1770, 1771, 1772, 1773, 1774, + 1775, 1776, 1777, 1778, 1779, 1780, 1781, 1782, + 1783, 1784, 1785, 1786, 1787, 1788, 1789, 1790, + 1791, 1792, 1793, 1794, 1795, 1796, 1797, 1798, + 1799, 1800, 1801, 1802, 1803, 1804, 1805, 1806, + 1807, 614, 614, 627, 614, 614, 614, 614, + 614, 614, 614, 627, 614, 614, 650, 1808, + 627, 629, 614, 614, 614, 614, 614, 614, + 614, 614, 614, 614, 614, 614, 614, 614, + 614, 614, 614, 614, 614, 614, 614, 614, + 614, 614, 614, 614, 614, 614, 614, 614, + 614, 614, 614, 614, 614, 614, 614, 626, + 1163, 1163, 627, 1809, 614, 649, 627, 614, + 627, 1810, 1811, 1812, 1813, 1814, 1815, 1816, + 1817, 1818, 1819, 1820, 1821, 1822, 1823, 1824, + 1825, 1826, 1827, 1828, 1829, 1830, 1831, 1832, + 1833, 1834, 1835, 1836, 1837, 1838, 1839, 1840, + 1841, 1842, 1843, 1844, 1845, 1846, 1847, 1848, + 1849, 1850, 1851, 1852, 1853, 1854, 1855, 1856, + 1857, 1858, 1859, 1860, 1861, 1862, 1863, 1864, + 1865, 1866, 1867, 1868, 1869, 1870, 1871, 1872, + 1873, 1874, 1875, 1876, 1877, 1878, 1879, 1880, + 1881, 1882, 1883, 1884, 1885, 1886, 1887, 1888, + 1889, 1890, 1891, 1892, 1893, 1894, 1895, 1896, + 1897, 1898, 1899, 1900, 1901, 1902, 1903, 1904, + 1905, 1906, 1907, 1908, 1909, 1910, 1911, 1912, + 1913, 1914, 1915, 1916, 1917, 1918, 1919, 1920, + 1921, 1922, 1923, 1924, 1925, 1926, 1927, 1928, + 1929, 1930, 1931, 1932, 1933, 1934, 1935, 1936, + 1937, 1938, 1939, 1940, 1941, 1942, 1943, 1944, + 1945, 1946, 1947, 1948, 1949, 1950, 1951, 1952, + 1953, 1954, 1955, 1956, 1957, 1958, 1959, 1960, + 1961, 1962, 1963, 1964, 1965, 1966, 1967, 1968, + 1969, 1970, 1971, 1972, 1973, 1974, 1975, 1976, + 1977, 1978, 1979, 1980, 1981, 1982, 1983, 1984, + 1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, + 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, + 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, + 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, + 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, + 2025, 2026, 2027, 2028, 2029, 2030, 2031, 2032, + 2033, 2034, 2035, 2036, 2037, 2038, 2039, 2040, + 2041, 2042, 2043, 2044, 2045, 2046, 2047, 2048, + 2049, 2050, 2051, 2052, 2053, 2054, 2055, 2056, + 2057, 2058, 2059, 2060, 2061, 2062, 2063, 2064, + 2065, 2066, 2067, 2068, 2069, 2070, 2071, 2072, + 2073, 2074, 2075, 2076, 2077, 2078, 2079, 2080, + 2081, 2082, 2083, 2084, 2085, 2086, 2087, 0, + 0, 2088, 2089, 2090, 2091, 2092, 2093, 0, + 0, 2094, 2095, 2096, 2097, 2098, 2099, 2100, + 2101, 2102, 2103, 2104, 2105, 2106, 2107, 2108, + 2109, 2110, 2111, 2112, 2113, 2114, 2115, 2116, 2117, 2118, 2119, 2120, 2121, 2122, 2123, 2124, - 0, 2125, 2126, 2127, 2127, 2127, 2127, 2127, - 2128, 2127, 2127, 2127, 1459, 2129, 2130, 2131, - 2132, 1087, 2133, 1087, 1087, 1087, 1087, 9, - 2134, 2135, 2136, 2137, 2135, 2135, 2136, 2137, - 2135, 9, 9, 9, 9, 2138, 2139, 2140, - 9, 2141, 2142, 2143, 2144, 2145, 2146, 2147, - 76, 10, 10, 10, 2148, 2149, 9, 2150, - 2151, 9, 81, 93, 9, 2152, 9, 2153, - 48, 48, 9, 9, 9, 2154, 12, 13, - 2155, 2156, 2157, 9, 9, 9, 9, 9, - 9, 9, 9, 75, 9, 48, 9, 9, - 2158, 9, 9, 9, 9, 9, 9, 9, - 2127, 1459, 1459, 1459, 1459, 1459, 0, 2159, - 2160, 2161, 2162, 1459, 1459, 1459, 1459, 1459, - 1459, 2163, 2164, 0, 0, 2165, 2166, 2167, - 2168, 2169, 2170, 2171, 2172, 2173, 2174, 2175, - 2176, 2177, 2178, 2179, 2180, 2181, 2182, 2183, - 2184, 2185, 2186, 2187, 2188, 2189, 2190, 2191, - 0, 2192, 2193, 2194, 2195, 2196, 2197, 2198, - 2199, 2200, 2201, 2202, 2203, 2204, 0, 0, - 0, 11, 11, 11, 11, 11, 11, 11, - 11, 2205, 11, 11, 11, 11, 11, 11, - 11, 11, 11, 11, 11, 11, 11, 11, - 11, 11, 11, 11, 11, 11, 11, 11, - 11, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 543, 543, 569, 569, 543, 543, 543, - 543, 569, 569, 569, 543, 543, 842, 842, - 842, 842, 543, 842, 842, 842, 569, 569, - 543, 556, 543, 569, 569, 556, 556, 556, - 556, 543, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 2206, 2207, 2208, 2209, 77, 2210, 2211, - 2212, 77, 2213, 2214, 2215, 2215, 2215, 2216, - 2217, 2218, 2218, 2219, 2220, 77, 2221, 2222, - 77, 75, 2223, 2224, 2225, 2225, 2225, 77, - 77, 2226, 2227, 2228, 77, 2229, 77, 2230, - 77, 2229, 77, 2231, 2232, 2233, 2208, 84, + 2125, 2126, 2127, 2128, 2129, 2130, 2131, 0, + 0, 2132, 2133, 2134, 2135, 2136, 2137, 0, + 0, 2138, 2139, 2140, 2141, 2142, 2143, 2144, + 2145, 0, 2146, 0, 2147, 0, 2148, 0, + 2149, 2150, 2151, 2152, 2153, 2154, 2155, 2156, + 2157, 2158, 2159, 2160, 2161, 2162, 2163, 2164, + 2165, 2166, 2167, 2168, 2169, 2170, 2171, 2172, + 2173, 2174, 2175, 2176, 2177, 2178, 2179, 0, + 0, 2180, 2181, 2182, 2183, 2184, 2185, 2186, + 2187, 2188, 2189, 2190, 2191, 2192, 2193, 2194, + 2195, 2196, 2197, 2198, 2199, 2200, 2201, 2202, + 2203, 2204, 2205, 2206, 2207, 2208, 2209, 2210, + 2211, 2212, 2213, 2214, 2215, 2216, 2217, 2218, + 2219, 2220, 2221, 2222, 2223, 2224, 2225, 2226, + 2227, 2228, 2229, 2230, 2231, 2232, 0, 2233, 2234, 2235, 2236, 2237, 2238, 2239, 2240, 2241, - 2242, 2243, 2244, 77, 2245, 2246, 2247, 2248, - 2249, 2250, 75, 75, 75, 75, 2251, 2252, - 2234, 2253, 2254, 77, 75, 77, 77, 2255, - 841, 2256, 2257, 2258, 2259, 2260, 2261, 2262, - 2263, 2264, 2265, 2266, 2267, 2268, 2269, 2270, - 2271, 2272, 2273, 2274, 2275, 2276, 2277, 2278, - 2279, 2280, 2281, 2282, 2283, 2284, 2285, 2286, - 2287, 2288, 2289, 2290, 2291, 2292, 2293, 2294, - 2295, 2296, 2297, 2298, 2299, 2300, 2301, 2302, - 2303, 1458, 1458, 1458, 2304, 2305, 1458, 1458, - 1458, 1458, 2306, 77, 77, 0, 0, 0, - 0, 2307, 75, 2308, 75, 2309, 79, 79, - 79, 79, 79, 2310, 2311, 77, 77, 77, - 77, 75, 77, 77, 75, 77, 77, 75, - 77, 77, 79, 79, 77, 77, 77, 2312, - 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, 2313, 2314, - 2315, 2316, 77, 2317, 77, 2318, 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, 75, 75, 75, - 75, 75, 75, 75, 75, 75, 75, 75, - 75, 75, 2319, 2319, 2320, 2321, 75, 75, - 75, 2322, 2323, 2319, 2324, 2325, 2319, 75, - 75, 75, 2319, 14, 85, 75, 2319, 2319, - 75, 75, 75, 2319, 2319, 2319, 2319, 75, - 2319, 2319, 2319, 2319, 2326, 2327, 2328, 2329, - 75, 75, 75, 75, 2319, 2330, 2331, 2319, - 2332, 2333, 2319, 2319, 2319, 75, 75, 75, - 75, 75, 2319, 75, 2319, 2334, 2319, 2319, - 2319, 2319, 2335, 2319, 2336, 2337, 2338, 2319, - 2339, 2340, 2341, 2319, 2319, 2319, 2342, 75, - 75, 75, 75, 2319, 2319, 2319, 2319, 75, - 75, 75, 75, 75, 75, 75, 75, 75, - 2319, 2343, 2344, 2345, 75, 2346, 2347, 2319, - 2319, 2319, 2319, 2319, 2319, 75, 2348, 2349, + 2242, 2243, 2244, 2245, 2246, 2247, 0, 2248, + 2249, 2250, 2251, 2252, 2253, 2254, 2255, 2256, + 2257, 2258, 2259, 2260, 2261, 0, 0, 2262, + 2263, 2264, 2265, 2266, 2267, 0, 2268, 2269, + 2270, 2271, 2272, 2273, 2274, 2275, 2276, 2277, + 2278, 2279, 2280, 2281, 2282, 2283, 2284, 2285, + 2286, 0, 0, 2287, 2288, 2289, 0, 2290, + 2291, 2292, 2293, 2294, 2295, 2296, 2297, 2298, + 0, 2299, 2300, 2301, 2301, 2301, 2301, 2301, + 2302, 2301, 2301, 2301, 1538, 2303, 2304, 2305, + 2306, 1161, 2307, 1161, 1161, 1161, 1161, 8, + 2308, 2309, 2310, 2311, 2309, 2309, 2310, 2311, + 2309, 8, 8, 8, 8, 2312, 2313, 2314, + 8, 2315, 2316, 2317, 2318, 2319, 2320, 2321, + 75, 9, 9, 9, 2322, 2323, 8, 2324, + 2325, 8, 80, 92, 8, 2326, 8, 2327, + 47, 47, 8, 8, 8, 2328, 11, 12, + 2329, 2330, 2331, 8, 8, 8, 8, 8, + 8, 8, 8, 74, 8, 47, 8, 8, + 2332, 8, 8, 8, 8, 8, 8, 8, + 2301, 1538, 1538, 1538, 1538, 1538, 0, 2333, + 2334, 2335, 2336, 1538, 1538, 1538, 1538, 1538, + 1538, 2337, 2338, 0, 0, 2339, 2340, 2341, + 2342, 2343, 2344, 2345, 2346, 2347, 2348, 2349, 2350, 2351, 2352, 2353, 2354, 2355, 2356, 2357, - 2358, 2359, 2360, 2361, 2362, 2363, 2364, 2319, - 2319, 2365, 2366, 2367, 2368, 2369, 2370, 2371, - 2372, 2373, 2374, 2319, 2319, 2319, 75, 75, - 2319, 2319, 2375, 2376, 75, 75, 75, 75, - 75, 2319, 75, 75, 75, 75, 75, 75, - 75, 75, 75, 2377, 2319, 75, 75, 2319, - 2319, 2378, 2379, 2319, 2380, 2381, 2382, 2383, - 2384, 2319, 2319, 2385, 2386, 2387, 2388, 2319, - 2319, 2319, 75, 75, 75, 75, 75, 2319, - 2319, 75, 75, 75, 75, 75, 75, 75, - 75, 75, 2319, 2319, 2319, 2319, 2319, 75, - 75, 2319, 2319, 75, 75, 75, 75, 2319, - 2319, 2319, 2319, 2319, 2319, 2319, 2319, 2319, - 2319, 2389, 2390, 2391, 2392, 2319, 2319, 2319, - 2319, 2319, 2319, 2393, 2394, 2395, 2396, 75, - 75, 2319, 2319, 2319, 2319, 2319, 2319, 2319, - 2319, 2319, 2319, 2319, 2319, 2319, 2319, 2319, - 2319, 77, 77, 77, 77, 77, 77, 77, - 77, 12, 13, 12, 13, 77, 77, 77, - 77, 77, 77, 77, 77, 77, 77, 77, - 77, 77, 77, 2397, 2397, 77, 77, 77, - 77, 2319, 2319, 77, 77, 77, 77, 77, - 77, 79, 2398, 2399, 77, 77, 77, 77, - 77, 77, 77, 77, 77, 77, 77, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 77, 75, 77, 77, - 77, 77, 77, 77, 77, 77, 77, 77, - 77, 79, 77, 77, 77, 77, 77, 77, - 77, 77, 77, 77, 77, 77, 841, 77, - 77, 77, 77, 77, 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, 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, - 79, 77, 77, 77, 77, 77, 77, 77, - 77, 77, 77, 77, 77, 75, 75, 75, - 75, 75, 75, 77, 77, 77, 77, 77, - 77, 77, 2397, 2397, 2397, 2397, 79, 79, - 79, 2397, 79, 79, 2397, 77, 77, 77, - 77, 79, 79, 79, 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, - 77, 77, 77, 77, 77, 77, 77, 77, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 77, 77, 77, 77, 77, 77, 77, - 77, 77, 77, 77, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 2400, 2401, 2402, 2403, 2404, 2405, 2406, - 2407, 2408, 2409, 2410, 2411, 2412, 2413, 2414, + 2358, 2359, 2360, 2361, 2362, 2363, 2364, 2365, + 0, 2366, 2367, 2368, 2369, 2370, 2371, 2372, + 2373, 2374, 2375, 2376, 2377, 2378, 0, 0, + 0, 10, 10, 10, 10, 10, 10, 10, + 10, 2379, 10, 10, 10, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 10, + 10, 10, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 614, 614, 640, 640, 614, 614, 614, + 614, 640, 640, 640, 614, 614, 914, 914, + 914, 914, 614, 914, 914, 914, 640, 640, + 614, 627, 614, 640, 640, 627, 627, 627, + 627, 614, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 2380, 2381, 2382, 2383, 76, 2384, 2385, + 2386, 76, 2387, 2388, 2389, 2390, 2391, 2392, + 2393, 2394, 2395, 2396, 2397, 76, 2398, 2399, + 76, 74, 2400, 2401, 2402, 2403, 2404, 76, + 76, 2405, 2406, 2407, 76, 2408, 76, 2409, + 76, 2410, 76, 2411, 2412, 2413, 2414, 83, 2415, 2416, 2417, 2418, 2419, 2420, 2421, 2422, - 2423, 2424, 2425, 2426, 2427, 2428, 2429, 2430, - 2431, 2432, 2433, 2434, 2435, 2436, 2437, 2438, - 2439, 2440, 2441, 2442, 2443, 2444, 2445, 2446, - 2447, 2448, 2449, 2450, 2451, 2452, 2453, 2454, - 2455, 2456, 2457, 2458, 2459, 2460, 2461, 2462, - 2463, 2464, 2465, 2466, 2467, 2468, 2469, 2470, - 2471, 2472, 2473, 2474, 2475, 2476, 2477, 2478, - 2479, 2480, 2481, 2482, 2483, 2484, 2485, 2486, - 2487, 2488, 2489, 2490, 2491, 2492, 2493, 2494, - 2495, 2496, 2497, 2498, 2499, 2500, 2501, 2502, - 2503, 2504, 2505, 2506, 2507, 2508, 2509, 2510, - 2511, 2512, 2513, 2514, 2515, 2516, 2517, 2518, - 2519, 2520, 2521, 2522, 2523, 2524, 2525, 2526, - 2527, 2528, 2529, 2530, 2531, 2532, 2533, 2534, - 2535, 2536, 2537, 2538, 1211, 1211, 1211, 1211, - 1211, 1211, 1211, 1211, 1211, 1211, 1211, 1211, - 1211, 1211, 1211, 1211, 1211, 1211, 1211, 1211, - 1211, 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, 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, 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, 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, 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, 79, 79, 77, 77, 77, - 77, 77, 77, 77, 77, 77, 77, 79, - 75, 77, 77, 77, 77, 77, 77, 77, - 77, 79, 75, 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, 77, - 77, 77, 77, 77, 77, 77, 77, 77, - 77, 77, 77, 77, 77, 77, 77, 77, - 77, 75, 75, 75, 2539, 2539, 2540, 2540, - 75, 79, 79, 79, 79, 79, 79, 77, - 79, 79, 79, 79, 79, 79, 79, 79, - 79, 79, 79, 79, 77, 2397, 2397, 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, 79, 79, - 79, 79, 79, 79, 79, 79, 79, 79, - 79, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 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, - 2539, 79, 79, 79, 79, 79, 79, 79, - 79, 79, 79, 79, 79, 79, 79, 79, - 2397, 79, 79, 79, 79, 79, 79, 77, - 77, 77, 77, 77, 77, 77, 77, 77, - 77, 79, 79, 79, 2397, 79, 79, 79, - 79, 79, 79, 79, 79, 79, 79, 79, - 79, 79, 2397, 79, 79, 79, 79, 79, - 79, 79, 79, 2397, 2397, 2541, 79, 79, - 79, 79, 79, 79, 79, 79, 79, 79, - 79, 79, 79, 79, 79, 79, 2397, 2397, - 79, 79, 79, 79, 79, 2397, 2397, 79, - 79, 79, 79, 79, 79, 79, 79, 2397, - 79, 79, 79, 79, 79, 2397, 79, 79, - 79, 79, 79, 79, 79, 79, 79, 79, - 79, 79, 79, 79, 79, 79, 79, 79, - 79, 79, 79, 2397, 79, 79, 79, 79, - 79, 79, 79, 2397, 2397, 79, 2397, 79, - 79, 79, 79, 2397, 79, 79, 2397, 79, - 79, 79, 79, 79, 79, 79, 2397, 77, - 77, 79, 79, 2397, 2397, 79, 79, 79, - 79, 79, 79, 79, 77, 79, 77, 79, - 77, 77, 77, 77, 77, 77, 79, 77, - 77, 77, 79, 77, 77, 77, 77, 77, - 77, 2397, 77, 77, 77, 77, 77, 77, - 77, 77, 77, 77, 79, 79, 77, 77, - 77, 77, 77, 77, 77, 77, 77, 77, - 77, 77, 77, 77, 77, 79, 77, 77, - 79, 77, 77, 77, 77, 2397, 77, 2397, - 77, 77, 77, 77, 2397, 2397, 2397, 77, - 2397, 77, 77, 77, 77, 77, 77, 77, - 77, 77, 77, 77, 79, 79, 79, 79, - 79, 12, 13, 12, 13, 12, 13, 12, - 13, 12, 13, 12, 13, 12, 13, 1211, - 1211, 1211, 1211, 1211, 1211, 1211, 1211, 1211, - 1211, 1211, 1211, 1211, 1211, 1211, 1211, 1211, - 1211, 1211, 1211, 1211, 1211, 1211, 1211, 1211, - 1211, 1211, 1211, 1211, 1211, 77, 2397, 2397, - 2397, 77, 77, 77, 77, 77, 77, 77, - 77, 77, 79, 77, 77, 77, 77, 77, - 77, 77, 77, 77, 77, 77, 77, 77, - 77, 2397, 77, 77, 77, 77, 77, 77, - 77, 77, 77, 77, 77, 77, 77, 77, - 2397, 2319, 75, 75, 2319, 2319, 12, 13, - 75, 2319, 2319, 75, 2319, 2319, 2319, 75, - 75, 75, 75, 75, 2319, 2319, 2319, 2319, - 75, 75, 75, 75, 75, 2319, 2319, 2319, - 75, 75, 75, 2319, 2319, 2319, 2319, 12, - 13, 12, 13, 12, 13, 12, 13, 12, - 13, 75, 75, 75, 75, 75, 75, 75, - 75, 75, 75, 75, 75, 75, 75, 75, - 75, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 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, 2539, 2539, 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, 75, 75, 75, - 75, 75, 75, 75, 75, 75, 75, 75, - 75, 75, 75, 75, 75, 75, 75, 75, - 75, 75, 75, 75, 12, 13, 12, 13, - 12, 13, 12, 13, 12, 13, 12, 13, - 12, 13, 12, 13, 12, 13, 12, 13, - 12, 13, 75, 75, 2319, 2319, 2319, 2319, - 2319, 2319, 75, 2319, 2319, 2319, 2319, 2319, - 2319, 2319, 2319, 2319, 2319, 2319, 2319, 2319, - 2319, 75, 75, 75, 75, 75, 75, 75, - 75, 2319, 75, 75, 75, 75, 75, 75, - 75, 2319, 2319, 2319, 2319, 2319, 2319, 75, - 75, 75, 2319, 75, 75, 75, 75, 2319, - 2319, 2319, 2319, 2319, 75, 2319, 2319, 75, - 75, 12, 13, 12, 13, 2319, 75, 75, - 75, 75, 2319, 75, 2319, 2319, 2319, 75, - 75, 2319, 2319, 75, 75, 75, 75, 75, - 75, 75, 75, 75, 75, 2319, 2319, 2319, - 2319, 2319, 2319, 75, 75, 12, 13, 75, - 75, 75, 75, 75, 75, 75, 75, 75, - 75, 75, 75, 2319, 2319, 2542, 2319, 2319, - 2319, 2319, 2319, 2319, 2319, 2319, 2319, 2319, - 2319, 2319, 2319, 2319, 2319, 2319, 75, 2319, - 2319, 2319, 2319, 75, 75, 2319, 75, 2319, - 75, 75, 2319, 75, 2319, 2319, 2319, 2319, - 75, 75, 75, 75, 75, 2319, 2319, 75, - 75, 75, 75, 75, 75, 2319, 2319, 2319, - 75, 75, 75, 75, 75, 75, 75, 75, - 75, 75, 75, 75, 75, 75, 75, 75, - 75, 75, 75, 75, 75, 75, 75, 75, - 2319, 2319, 75, 75, 75, 75, 75, 75, - 75, 75, 75, 75, 75, 2319, 2319, 75, - 75, 75, 75, 2319, 2319, 2319, 2319, 75, - 2319, 2319, 75, 75, 2319, 2543, 2544, 2545, - 75, 75, 2319, 2319, 2319, 2319, 2319, 2319, - 2319, 2319, 2319, 2319, 2319, 2319, 2319, 2319, - 2319, 2319, 2319, 2319, 2319, 2319, 2319, 2319, - 2319, 2319, 2319, 2319, 2319, 2319, 2319, 2319, - 2319, 2319, 2319, 2319, 2319, 2319, 2319, 2319, - 2319, 2319, 2319, 2319, 2319, 75, 75, 2319, - 2319, 2319, 2319, 2319, 2319, 2319, 2319, 75, - 2319, 2319, 2319, 2319, 2319, 2319, 2319, 2319, - 2319, 2319, 2319, 2319, 2319, 2319, 2319, 2319, - 2319, 2319, 2319, 2319, 2319, 2319, 2319, 2319, - 2319, 2319, 2319, 2319, 2319, 2319, 2319, 2319, - 2319, 2319, 2319, 2319, 2319, 2319, 2319, 2319, - 75, 75, 75, 75, 75, 2546, 2547, 2319, - 75, 75, 75, 2319, 2319, 2319, 2319, 2319, - 75, 75, 75, 75, 75, 2319, 2319, 2319, - 75, 75, 75, 75, 2319, 75, 75, 75, - 2319, 2319, 2319, 2319, 2319, 75, 2319, 75, - 75, 77, 77, 77, 77, 77, 79, 79, - 79, 77, 77, 77, 77, 77, 77, 77, - 77, 77, 77, 77, 77, 77, 77, 77, - 77, 77, 77, 77, 2397, 2397, 77, 77, - 77, 77, 77, 77, 77, 77, 77, 77, - 77, 77, 77, 77, 77, 77, 77, 77, - 77, 75, 75, 75, 75, 75, 75, 75, - 75, 75, 75, 75, 75, 75, 75, 75, - 75, 75, 75, 75, 75, 75, 77, 77, - 75, 75, 75, 75, 75, 75, 77, 77, - 77, 2397, 77, 77, 77, 77, 2397, 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, 0, 0, 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, 0, - 0, 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, 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, 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, 2548, - 77, 2549, 2550, 2551, 2552, 2553, 2554, 2555, - 2556, 2557, 2558, 2559, 2560, 2561, 2562, 2563, - 2564, 2565, 2566, 2567, 2568, 2569, 2570, 2571, - 2572, 2573, 2574, 2575, 2576, 2577, 2578, 2579, - 2580, 2581, 2582, 2583, 2584, 2585, 2586, 2587, - 2588, 2589, 2590, 2591, 2592, 2593, 2594, 2595, - 0, 2596, 2597, 2598, 2599, 2600, 2601, 2602, - 2603, 2604, 2605, 2606, 2607, 2608, 2609, 2610, - 2611, 2612, 2613, 2614, 2615, 2616, 2617, 2618, - 2619, 2620, 2621, 2622, 2623, 2624, 2625, 2626, - 2627, 2628, 2629, 2630, 2631, 2632, 2633, 2634, - 2635, 2636, 2637, 2638, 2639, 2640, 2641, 2642, - 0, 2643, 2644, 2645, 2646, 2647, 2648, 2649, - 2650, 2651, 2652, 2653, 2654, 2655, 2656, 2657, - 2658, 2659, 215, 2660, 2661, 215, 2662, 2663, - 215, 215, 215, 215, 215, 2664, 2665, 2666, - 2667, 2668, 2669, 2670, 2671, 2672, 2673, 2674, - 2675, 2676, 2677, 2678, 2679, 2680, 2681, 2682, - 2683, 2684, 2685, 2686, 2687, 2688, 2689, 2690, - 2691, 2692, 2693, 2694, 2695, 2696, 2697, 2698, - 2699, 2700, 2701, 2702, 2703, 2704, 2705, 2706, - 2707, 2708, 2709, 2710, 2711, 2712, 2713, 2714, - 2715, 2716, 2717, 2718, 2719, 2720, 2721, 2722, - 2723, 2724, 2725, 2726, 2727, 2728, 2729, 2730, - 2731, 2732, 2733, 2734, 2735, 2736, 2737, 2738, - 2739, 2740, 2741, 2742, 2743, 2744, 2745, 2746, - 2747, 2748, 2749, 2750, 2751, 2752, 2753, 2754, - 2755, 2756, 2757, 2758, 2759, 2760, 2761, 2762, - 2763, 2764, 2765, 2766, 2767, 215, 77, 77, - 77, 77, 77, 77, 2768, 2769, 2770, 2771, - 543, 543, 543, 2772, 2773, 0, 0, 0, - 0, 0, 9, 9, 9, 9, 1211, 9, - 9, 2774, 2775, 2776, 2777, 2778, 2779, 2780, - 2781, 2782, 2783, 2784, 2785, 2786, 2787, 2788, - 2789, 2790, 2791, 2792, 2793, 2794, 2795, 2796, - 2797, 2798, 2799, 2800, 2801, 2802, 2803, 2804, - 2805, 2806, 2807, 2808, 2809, 2810, 2811, 0, - 2812, 0, 0, 0, 0, 0, 2813, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 0, 0, 0, 0, 0, 0, 0, - 2814, 1047, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 1163, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 0, 341, 341, 341, 341, 341, 341, 341, - 0, 341, 341, 341, 341, 341, 341, 341, - 0, 341, 341, 341, 341, 341, 341, 341, - 0, 341, 341, 341, 341, 341, 341, 341, - 0, 341, 341, 341, 341, 341, 341, 341, - 0, 341, 341, 341, 341, 341, 341, 341, - 0, 341, 341, 341, 341, 341, 341, 341, - 0, 543, 543, 543, 543, 543, 543, 543, - 543, 543, 543, 543, 543, 543, 543, 543, - 543, 543, 543, 543, 543, 543, 543, 543, - 543, 543, 543, 543, 543, 543, 543, 543, - 543, 9, 9, 81, 93, 81, 93, 9, - 9, 9, 81, 93, 9, 81, 93, 9, - 9, 9, 9, 9, 9, 9, 9, 9, - 1087, 9, 9, 1087, 9, 81, 93, 9, - 9, 81, 93, 12, 13, 12, 13, 12, - 13, 12, 13, 9, 9, 9, 9, 9, - 524, 9, 9, 9, 9, 9, 9, 9, - 9, 9, 9, 1087, 1087, 9, 9, 9, - 9, 1087, 9, 2137, 9, 9, 9, 9, - 9, 9, 9, 9, 9, 9, 9, 9, - 9, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 2815, 2815, 2815, 2815, 2815, 2815, 2815, - 2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, - 2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, - 2815, 2815, 2815, 0, 2815, 2815, 2815, 2815, - 2816, 2815, 2815, 2815, 2815, 2815, 2815, 2815, - 2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, - 2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, - 2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, - 2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, - 2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, - 2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, - 2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, - 2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, - 2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, - 2815, 2815, 2815, 2815, 2817, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 2818, 2819, 2820, 2821, 2822, 2823, 2824, - 2825, 2826, 2827, 2828, 2829, 2830, 2831, 2832, - 2833, 2834, 2835, 2836, 2837, 2838, 2839, 2840, - 2841, 2842, 2843, 2844, 2845, 2846, 2847, 2848, - 2849, 2850, 2851, 2852, 2853, 2854, 2855, 2856, - 2857, 2858, 2859, 2860, 2861, 2862, 2863, 2864, - 2865, 2866, 2867, 2868, 2869, 2870, 2871, 2872, - 2873, 2874, 2875, 2876, 2877, 2878, 2879, 2880, - 2881, 2882, 2883, 2884, 2885, 2886, 2887, 2888, - 2889, 2890, 2891, 2892, 2893, 2894, 2895, 2896, - 2897, 2898, 2899, 2900, 2901, 2902, 2903, 2904, - 2905, 2906, 2907, 2908, 2909, 2910, 2911, 2912, - 2913, 2914, 2915, 2916, 2917, 2918, 2919, 2920, - 2921, 2922, 2923, 2924, 2925, 2926, 2927, 2928, - 2929, 2930, 2931, 2932, 2933, 2934, 2935, 2936, - 2937, 2938, 2939, 2940, 2941, 2942, 2943, 2944, - 2945, 2946, 2947, 2948, 2949, 2950, 2951, 2952, - 2953, 2954, 2955, 2956, 2957, 2958, 2959, 2960, - 2961, 2962, 2963, 2964, 2965, 2966, 2967, 2968, - 2969, 2970, 2971, 2972, 2973, 2974, 2975, 2976, - 2977, 2978, 2979, 2980, 2981, 2982, 2983, 2984, - 2985, 2986, 2987, 2988, 2989, 2990, 2991, 2992, - 2993, 2994, 2995, 2996, 2997, 2998, 2999, 3000, - 3001, 3002, 3003, 3004, 3005, 3006, 3007, 3008, - 3009, 3010, 3011, 3012, 3013, 3014, 3015, 3016, + 2423, 2424, 2425, 76, 2426, 2427, 2428, 2429, + 2430, 2431, 74, 74, 74, 74, 2432, 2433, + 2434, 2435, 2436, 76, 74, 76, 76, 2437, + 913, 2438, 2439, 2440, 2441, 2442, 2443, 2444, + 2445, 2446, 2447, 2448, 2449, 2450, 2451, 2452, + 2453, 2454, 2455, 2456, 2457, 2458, 2459, 2460, + 2461, 2462, 2463, 2464, 2465, 2466, 2467, 2468, + 2469, 2470, 2471, 2472, 2473, 2474, 2475, 2476, + 2477, 2478, 2479, 2480, 2481, 2482, 2483, 2484, + 2485, 1536, 1536, 1536, 2486, 2487, 1536, 1536, + 1536, 1536, 2488, 76, 76, 0, 0, 0, + 0, 2489, 74, 2490, 74, 2491, 78, 78, + 78, 78, 78, 2492, 2493, 76, 76, 76, + 76, 74, 76, 76, 74, 76, 76, 74, + 76, 76, 78, 78, 76, 76, 76, 2494, + 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, 2495, 2496, + 2497, 2498, 76, 2499, 76, 2500, 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, 74, 74, 74, + 74, 74, 74, 74, 74, 74, 74, 74, + 74, 74, 2501, 2501, 2502, 2503, 74, 74, + 74, 2504, 2505, 2501, 2506, 2507, 2501, 74, + 74, 74, 2501, 13, 84, 74, 2501, 2501, + 74, 74, 74, 2501, 2501, 2501, 2501, 74, + 2501, 2501, 2501, 2501, 2508, 2509, 2510, 2511, + 74, 74, 74, 74, 2501, 2512, 2513, 2501, + 2514, 2515, 2501, 2501, 2501, 74, 74, 74, + 74, 74, 2501, 74, 2501, 2516, 2501, 2501, + 2501, 2501, 2517, 2501, 2518, 2519, 2520, 2501, + 2521, 2522, 2523, 2501, 2501, 2501, 2524, 74, + 74, 74, 74, 2501, 2501, 2501, 2501, 74, + 74, 74, 74, 74, 74, 74, 74, 74, + 2501, 2525, 2526, 2527, 74, 2528, 2529, 2501, + 2501, 2501, 2501, 2501, 2501, 74, 2530, 2531, + 2532, 2533, 2534, 2535, 2536, 2537, 2538, 2539, + 2540, 2541, 2542, 2543, 2544, 2545, 2546, 2501, + 2501, 2547, 2548, 2549, 2550, 2551, 2552, 2553, + 2554, 2555, 2556, 2501, 2501, 2501, 74, 74, + 2501, 2501, 2557, 2558, 74, 74, 74, 74, + 74, 2501, 74, 74, 74, 74, 74, 74, + 74, 74, 74, 2559, 2501, 74, 74, 2501, + 2501, 2560, 2561, 2501, 2562, 2563, 2564, 2565, + 2566, 2501, 2501, 2567, 2568, 2569, 2570, 2501, + 2501, 2501, 74, 74, 74, 74, 74, 2501, + 2501, 74, 74, 74, 74, 74, 74, 74, + 74, 74, 2501, 2501, 2501, 2501, 2501, 74, + 74, 2501, 2501, 74, 74, 74, 74, 2501, + 2501, 2501, 2501, 2501, 2501, 2501, 2501, 2501, + 2501, 2571, 2572, 2573, 2574, 2501, 2501, 2501, + 2501, 2501, 2501, 2575, 2576, 2577, 2578, 74, + 74, 2501, 2501, 2501, 2501, 2501, 2501, 2501, + 2501, 2501, 2501, 2501, 2501, 2501, 2501, 2501, + 2501, 76, 76, 76, 76, 76, 76, 76, + 76, 11, 12, 11, 12, 76, 76, 76, + 76, 76, 76, 76, 76, 76, 76, 76, + 76, 76, 76, 2579, 2579, 76, 76, 76, + 76, 2501, 2501, 76, 76, 76, 76, 76, + 76, 78, 2580, 2581, 76, 76, 76, 76, + 76, 76, 76, 76, 76, 76, 76, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 76, 74, 76, 76, + 76, 76, 76, 76, 76, 76, 76, 76, + 76, 78, 76, 76, 76, 76, 76, 76, + 76, 76, 76, 76, 76, 76, 913, 76, + 76, 76, 76, 76, 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, 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, + 78, 76, 76, 76, 76, 76, 76, 76, + 76, 76, 76, 76, 76, 74, 74, 74, + 74, 74, 74, 76, 76, 76, 76, 76, + 76, 76, 2579, 2579, 2579, 2579, 78, 78, + 78, 2579, 78, 78, 2579, 76, 76, 76, + 76, 78, 78, 78, 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, 76, + 76, 76, 76, 76, 76, 76, 76, 76, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 76, 76, 76, 76, 76, 76, 76, + 76, 76, 76, 76, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 2582, 2583, 2584, 2585, 2586, 2587, 2588, + 2589, 2590, 2591, 2592, 2593, 2594, 2595, 2596, + 2597, 2598, 2599, 2600, 2601, 2602, 2603, 2604, + 2605, 2606, 2607, 2608, 2609, 2610, 2611, 2612, + 2613, 2614, 2615, 2616, 2617, 2618, 2619, 2620, + 2621, 2622, 2623, 2624, 2625, 2626, 2627, 2628, + 2629, 2630, 2631, 2632, 2633, 2634, 2635, 2636, + 2637, 2638, 2639, 2640, 2641, 2642, 2643, 2644, + 2645, 2646, 2647, 2648, 2649, 2650, 2651, 2652, + 2653, 2654, 2655, 2656, 2657, 2658, 2659, 2660, + 2661, 2662, 2663, 2664, 2665, 2666, 2667, 2668, + 2669, 2670, 2671, 2672, 2673, 2674, 2675, 2676, + 2677, 2678, 2679, 2680, 2681, 2682, 2683, 2684, + 2685, 2686, 2687, 2688, 2689, 2690, 2691, 2692, + 2693, 2694, 2695, 2696, 2697, 2698, 2699, 2700, + 2701, 2702, 2703, 2704, 2705, 2706, 2707, 2708, + 2709, 2710, 2711, 2712, 2713, 2714, 2715, 2716, + 2717, 2718, 2719, 2720, 1288, 1288, 1288, 1288, + 1288, 1288, 1288, 1288, 1288, 1288, 1288, 1288, + 1288, 1288, 1288, 1288, 1288, 1288, 1288, 1288, + 1288, 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, 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, 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, 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, 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, 78, 78, 76, 76, 76, + 76, 76, 76, 76, 76, 76, 76, 78, + 74, 76, 76, 76, 76, 76, 76, 76, + 76, 78, 74, 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, 76, 76, + 76, 76, 76, 76, 76, 76, 76, 76, + 76, 76, 76, 76, 76, 76, 76, 76, + 76, 74, 74, 74, 2721, 2721, 2722, 2722, + 74, 78, 78, 78, 78, 78, 78, 76, + 78, 78, 78, 78, 78, 78, 78, 78, + 78, 78, 78, 78, 76, 2579, 2579, 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, 78, 78, + 78, 78, 78, 78, 78, 78, 78, 78, + 78, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 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, + 2721, 78, 78, 78, 78, 78, 78, 78, + 78, 78, 78, 78, 78, 78, 78, 78, + 2579, 78, 78, 78, 78, 78, 78, 76, + 76, 76, 76, 76, 76, 76, 76, 76, + 76, 78, 78, 78, 2579, 78, 78, 78, + 78, 78, 78, 78, 78, 78, 78, 78, + 78, 78, 2579, 78, 78, 78, 78, 78, + 78, 78, 78, 2579, 2579, 2723, 78, 78, + 78, 78, 78, 78, 78, 78, 78, 78, + 78, 78, 78, 78, 78, 78, 2579, 2579, + 78, 78, 78, 78, 78, 2579, 2579, 78, + 78, 78, 78, 78, 78, 78, 78, 2579, + 78, 78, 78, 78, 78, 2579, 78, 78, + 78, 78, 78, 78, 78, 78, 78, 78, + 78, 78, 78, 78, 78, 78, 78, 78, + 78, 78, 78, 2579, 78, 78, 78, 78, + 78, 78, 78, 2579, 2579, 78, 2579, 78, + 78, 78, 78, 2579, 78, 78, 2579, 78, + 78, 78, 78, 78, 78, 78, 2579, 76, + 76, 78, 78, 2579, 2579, 78, 78, 78, + 78, 78, 78, 78, 76, 78, 76, 78, + 76, 76, 76, 76, 76, 76, 78, 76, + 76, 76, 78, 76, 76, 76, 76, 76, + 76, 2579, 76, 76, 76, 76, 76, 76, + 76, 76, 76, 76, 78, 78, 76, 76, + 76, 76, 76, 76, 76, 76, 76, 76, + 76, 76, 76, 76, 76, 78, 76, 76, + 78, 76, 76, 76, 76, 2579, 76, 2579, + 76, 76, 76, 76, 2579, 2579, 2579, 76, + 2579, 76, 76, 76, 76, 76, 76, 76, + 76, 76, 76, 76, 78, 78, 78, 78, + 78, 11, 12, 11, 12, 11, 12, 11, + 12, 11, 12, 11, 12, 11, 12, 1288, + 1288, 1288, 1288, 1288, 1288, 1288, 1288, 1288, + 1288, 1288, 1288, 1288, 1288, 1288, 1288, 1288, + 1288, 1288, 1288, 1288, 1288, 1288, 1288, 1288, + 1288, 1288, 1288, 1288, 1288, 76, 2579, 2579, + 2579, 76, 76, 76, 76, 76, 76, 76, + 76, 76, 78, 76, 76, 76, 76, 76, + 76, 76, 76, 76, 76, 76, 76, 76, + 76, 2579, 76, 76, 76, 76, 76, 76, + 76, 76, 76, 76, 76, 76, 76, 76, + 2579, 2501, 74, 74, 2501, 2501, 11, 12, + 74, 2501, 2501, 74, 2501, 2501, 2501, 74, + 74, 74, 74, 74, 2501, 2501, 2501, 2501, + 74, 74, 74, 74, 74, 2501, 2501, 2501, + 74, 74, 74, 2501, 2501, 2501, 2501, 11, + 12, 11, 12, 11, 12, 11, 12, 11, + 12, 74, 74, 74, 74, 74, 74, 74, + 74, 74, 74, 74, 74, 74, 74, 74, + 74, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 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, 74, 74, 74, 74, 74, 74, 74, + 74, 74, 74, 74, 74, 2721, 2721, 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, 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, 11, 12, 11, 12, + 11, 12, 11, 12, 11, 12, 11, 12, + 11, 12, 11, 12, 11, 12, 11, 12, + 11, 12, 74, 74, 2501, 2501, 2501, 2501, + 2501, 2501, 74, 2501, 2501, 2501, 2501, 2501, + 2501, 2501, 2501, 2501, 2501, 2501, 2501, 2501, + 2501, 74, 74, 74, 74, 74, 74, 74, + 74, 2501, 74, 74, 74, 74, 74, 74, + 74, 2501, 2501, 2501, 2501, 2501, 2501, 74, + 74, 74, 2501, 74, 74, 74, 74, 2501, + 2501, 2501, 2501, 2501, 74, 2501, 2501, 74, + 74, 11, 12, 11, 12, 2501, 74, 74, + 74, 74, 2501, 74, 2501, 2501, 2501, 74, + 74, 2501, 2501, 74, 74, 74, 74, 74, + 74, 74, 74, 74, 74, 2501, 2501, 2501, + 2501, 2501, 2501, 74, 74, 11, 12, 74, + 74, 74, 74, 74, 74, 74, 74, 74, + 74, 74, 74, 2501, 2501, 2724, 2501, 2501, + 2501, 2501, 2501, 2501, 2501, 2501, 2501, 2501, + 2501, 2501, 2501, 2501, 2501, 2501, 74, 2501, + 2501, 2501, 2501, 74, 74, 2501, 74, 2501, + 74, 74, 2501, 74, 2501, 2501, 2501, 2501, + 74, 74, 74, 74, 74, 2501, 2501, 74, + 74, 74, 74, 74, 74, 2501, 2501, 2501, + 74, 74, 74, 74, 74, 74, 74, 74, + 74, 74, 74, 74, 74, 74, 74, 74, + 74, 74, 74, 74, 74, 74, 74, 74, + 2501, 2501, 74, 74, 74, 74, 74, 74, + 74, 74, 74, 74, 74, 2501, 2501, 74, + 74, 74, 74, 2501, 2501, 2501, 2501, 74, + 2501, 2501, 74, 74, 2501, 2725, 2726, 2727, + 74, 74, 2501, 2501, 2501, 2501, 2501, 2501, + 2501, 2501, 2501, 2501, 2501, 2501, 2501, 2501, + 2501, 2501, 2501, 2501, 2501, 2501, 2501, 2501, + 2501, 2501, 2501, 2501, 2501, 2501, 2501, 2501, + 2501, 2501, 2501, 2501, 2501, 2501, 2501, 2501, + 2501, 2501, 2501, 2501, 2501, 74, 74, 2501, + 2501, 2501, 2501, 2501, 2501, 2501, 2501, 74, + 2501, 2501, 2501, 2501, 2501, 2501, 2501, 2501, + 2501, 2501, 2501, 2501, 2501, 2501, 2501, 2501, + 2501, 2501, 2501, 2501, 2501, 2501, 2501, 2501, + 2501, 2501, 2501, 2501, 2501, 2501, 2501, 2501, + 2501, 2501, 2501, 2501, 2501, 2501, 2501, 2501, + 74, 74, 74, 74, 74, 2728, 2729, 2501, + 74, 74, 74, 2501, 2501, 2501, 2501, 2501, + 74, 74, 74, 74, 74, 2501, 2501, 2501, + 74, 74, 74, 74, 2501, 74, 74, 74, + 2501, 2501, 2501, 2501, 2501, 74, 2501, 74, + 74, 76, 76, 76, 76, 76, 78, 78, + 78, 76, 76, 76, 76, 76, 76, 76, + 76, 76, 76, 76, 76, 76, 76, 76, + 76, 76, 76, 76, 2579, 2579, 76, 76, + 76, 76, 76, 76, 76, 76, 76, 76, + 76, 76, 76, 76, 76, 76, 76, 76, + 76, 74, 74, 74, 74, 74, 74, 74, + 74, 74, 74, 74, 74, 74, 74, 74, + 74, 74, 74, 74, 74, 74, 76, 76, + 74, 74, 74, 74, 74, 74, 76, 76, + 76, 2579, 76, 76, 76, 76, 2579, 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, 0, 0, 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, 0, + 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, 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, 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, 2730, + 76, 2731, 2732, 2733, 2734, 2735, 2736, 2737, + 2738, 2739, 2740, 2741, 2742, 2743, 2744, 2745, + 2746, 2747, 2748, 2749, 2750, 2751, 2752, 2753, + 2754, 2755, 2756, 2757, 2758, 2759, 2760, 2761, + 2762, 2763, 2764, 2765, 2766, 2767, 2768, 2769, + 2770, 2771, 2772, 2773, 2774, 2775, 2776, 2777, + 2778, 2779, 2780, 2781, 2782, 2783, 2784, 2785, + 2786, 2787, 2788, 2789, 2790, 2791, 2792, 2793, + 2794, 2795, 2796, 2797, 2798, 2799, 2800, 2801, + 2802, 2803, 2804, 2805, 2806, 2807, 2808, 2809, + 2810, 2811, 2812, 2813, 2814, 2815, 2816, 2817, + 2818, 2819, 2820, 2821, 2822, 2823, 2824, 2825, + 2826, 2827, 2828, 2829, 2830, 2831, 2832, 2833, + 2834, 2835, 2836, 2837, 2838, 2839, 2840, 2841, + 2842, 2843, 2844, 2845, 2846, 2847, 2848, 2849, + 2850, 2851, 2852, 2853, 2854, 2855, 2856, 2857, + 2858, 2859, 2860, 2861, 2862, 2863, 2864, 2865, + 2866, 2867, 2868, 2869, 2870, 2871, 2872, 2873, + 2874, 2875, 2876, 2877, 2878, 2879, 2880, 2881, + 2882, 2883, 2884, 2885, 2886, 2887, 2888, 2889, + 2890, 2891, 2892, 2893, 2894, 2895, 2896, 2897, + 2898, 2899, 2900, 2901, 2902, 2903, 2904, 2905, + 2906, 2907, 2908, 2909, 2910, 2911, 2912, 2913, + 2914, 2915, 2916, 2917, 2918, 2919, 2920, 2921, + 2922, 2923, 2924, 2925, 2926, 2927, 2928, 2929, + 2930, 2931, 2932, 2933, 2934, 2935, 2936, 2937, + 2938, 2939, 2940, 2941, 2942, 2943, 2944, 2945, + 2946, 2947, 2948, 2949, 2950, 2951, 2952, 2953, + 2954, 2955, 2956, 2957, 2958, 2959, 76, 76, + 76, 76, 76, 76, 2960, 2961, 2962, 2963, + 614, 614, 614, 2964, 2965, 0, 0, 0, + 0, 0, 8, 8, 8, 8, 1288, 8, + 8, 2966, 2967, 2968, 2969, 2970, 2971, 2972, + 2973, 2974, 2975, 2976, 2977, 2978, 2979, 2980, + 2981, 2982, 2983, 2984, 2985, 2986, 2987, 2988, + 2989, 2990, 2991, 2992, 2993, 2994, 2995, 2996, + 2997, 2998, 2999, 3000, 3001, 3002, 3003, 0, + 3004, 0, 0, 0, 0, 0, 3005, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 0, 0, 0, 0, 0, 0, 0, + 3006, 1119, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1299, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 0, 345, 345, 345, 345, 345, 345, 345, + 0, 345, 345, 345, 345, 345, 345, 345, + 0, 345, 345, 345, 345, 345, 345, 345, + 0, 345, 345, 345, 345, 345, 345, 345, + 0, 345, 345, 345, 345, 345, 345, 345, + 0, 345, 345, 345, 345, 345, 345, 345, + 0, 345, 345, 345, 345, 345, 345, 345, + 0, 614, 614, 614, 614, 614, 614, 614, + 614, 614, 614, 614, 614, 614, 614, 614, + 614, 614, 614, 614, 614, 614, 614, 614, + 614, 614, 614, 614, 614, 614, 614, 614, + 614, 8, 8, 80, 92, 80, 92, 8, + 8, 8, 80, 92, 8, 80, 92, 8, + 8, 8, 8, 8, 8, 8, 8, 8, + 1161, 8, 8, 1161, 8, 80, 92, 8, + 8, 80, 92, 11, 12, 11, 12, 11, + 12, 11, 12, 8, 8, 8, 8, 8, + 594, 8, 8, 8, 8, 8, 8, 8, + 8, 8, 8, 1161, 1161, 8, 8, 8, + 8, 1161, 8, 2311, 8, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 8, + 8, 76, 76, 8, 8, 8, 11, 12, + 11, 12, 11, 12, 11, 12, 1161, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3007, 3007, 3007, 3007, 3007, 3007, 3007, + 3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, + 3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, + 3007, 3007, 3007, 0, 3007, 3007, 3007, 3007, + 3008, 3007, 3007, 3007, 3007, 3007, 3007, 3007, + 3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, + 3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, + 3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, + 3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, + 3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, + 3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, + 3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, + 3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, + 3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, + 3007, 3007, 3007, 3007, 3009, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3010, 3011, 3012, 3013, 3014, 3015, 3016, 3017, 3018, 3019, 3020, 3021, 3022, 3023, 3024, - 3025, 3026, 3027, 3028, 3029, 3030, 3031, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 2815, 2815, 2815, 2815, 2815, 2815, 2815, - 2815, 2815, 2815, 2815, 2815, 0, 0, 0, - 0, 3032, 3033, 3033, 3033, 2815, 3034, 3035, - 3036, 3037, 3038, 3037, 3038, 3037, 3038, 3037, - 3038, 3037, 3038, 2815, 2815, 3037, 3038, 3037, - 3038, 3037, 3038, 3037, 3038, 3039, 3040, 3041, - 3041, 2815, 3036, 3036, 3036, 3036, 3036, 3036, - 3036, 3036, 3036, 3042, 1089, 555, 1088, 3043, - 3043, 3044, 3034, 3034, 3034, 3034, 3034, 3045, - 2815, 3046, 3047, 3048, 3034, 3035, 3049, 2815, - 77, 0, 3035, 3035, 3035, 3035, 3035, 3050, - 3035, 3035, 3035, 3035, 3051, 3052, 3053, 3054, - 3055, 3056, 3057, 3058, 3059, 3060, 3061, 3062, - 3063, 3064, 3065, 3066, 3067, 3068, 3069, 3070, - 3071, 3072, 3073, 3074, 3035, 3075, 3076, 3077, - 3078, 3079, 3080, 3035, 3035, 3035, 3035, 3035, + 3025, 3026, 3027, 3028, 3029, 3030, 3031, 3032, + 3033, 3034, 3035, 3036, 3037, 3038, 3039, 3040, + 3041, 3042, 3043, 3044, 3045, 3046, 3047, 3048, + 3049, 3050, 3051, 3052, 3053, 3054, 3055, 3056, + 3057, 3058, 3059, 3060, 3061, 3062, 3063, 3064, + 3065, 3066, 3067, 3068, 3069, 3070, 3071, 3072, + 3073, 3074, 3075, 3076, 3077, 3078, 3079, 3080, 3081, 3082, 3083, 3084, 3085, 3086, 3087, 3088, - 3089, 3090, 3091, 3092, 3093, 3094, 3095, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3096, 3035, 3035, - 0, 0, 3097, 3098, 3099, 3100, 3101, 3102, - 3103, 3039, 3035, 3035, 3035, 3035, 3035, 3104, - 3035, 3035, 3035, 3035, 3105, 3106, 3107, 3108, - 3109, 3110, 3111, 3112, 3113, 3114, 3115, 3116, - 3117, 3118, 3119, 3120, 3121, 3122, 3123, 3124, - 3125, 3126, 3127, 3128, 3035, 3129, 3130, 3131, - 3132, 3133, 3134, 3035, 3035, 3035, 3035, 3035, - 3135, 3136, 3137, 3138, 3139, 3140, 3141, 3142, - 3143, 3144, 3145, 3146, 3147, 3148, 3149, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3150, 3151, 3152, 3153, 3035, 3154, 3035, 3035, - 3155, 3156, 3157, 3158, 3033, 3034, 3159, 3160, - 3161, 0, 0, 0, 0, 0, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 0, 3162, 3163, 3164, 3165, 3166, 3167, - 3168, 3169, 3170, 3171, 3172, 3173, 3174, 3175, - 3176, 3177, 3178, 3179, 3180, 3181, 3182, 3183, - 3184, 3185, 3186, 3187, 3188, 3189, 3190, 3191, - 3192, 3193, 3194, 3195, 3196, 3197, 3198, 3199, - 3200, 3201, 3202, 3203, 3204, 3205, 3206, 3207, - 3208, 3209, 3210, 3211, 3212, 3213, 3214, 3215, - 3216, 3217, 3218, 3219, 3220, 3221, 3222, 3223, - 3224, 3225, 3226, 3227, 3228, 3229, 3230, 3231, - 3232, 3233, 3234, 3235, 3236, 3237, 3238, 3239, - 3240, 3241, 3242, 3243, 3244, 3245, 3246, 3247, - 3248, 3249, 3250, 3251, 3252, 3253, 3254, 3255, - 0, 3256, 3256, 3257, 3258, 3259, 3260, 3261, - 3262, 3263, 3264, 3265, 3266, 3267, 3268, 3269, - 3270, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 0, 0, 0, 0, - 0, 2815, 2815, 2815, 2815, 2815, 2815, 2815, - 2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, - 2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, - 2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, - 2815, 2815, 2815, 2815, 2815, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3271, 3272, 3273, 3274, 3275, 3276, 3277, - 3278, 3279, 3280, 3281, 3282, 3283, 3284, 3285, - 3286, 3287, 3288, 3289, 3290, 3291, 3292, 3293, - 3294, 3295, 3296, 3297, 3298, 3299, 3300, 3301, - 0, 3302, 3303, 3304, 3305, 3306, 3307, 3308, - 3309, 3310, 3311, 3312, 3313, 3314, 3315, 3316, - 3317, 3318, 3319, 3320, 3321, 3322, 3323, 3324, - 3325, 3326, 3327, 3328, 3329, 3330, 3331, 3332, - 3333, 3334, 3335, 3336, 3337, 3338, 3339, 3340, - 3341, 1182, 1182, 1182, 1182, 1182, 1182, 1182, - 1182, 3342, 3343, 3344, 3345, 3346, 3347, 3348, - 3349, 3350, 3351, 3352, 3353, 3354, 3355, 3356, - 3357, 3358, 3359, 3360, 3361, 3362, 3363, 3364, - 3365, 3366, 3367, 3368, 3369, 3370, 3371, 3372, - 3373, 3374, 3375, 3376, 3377, 3378, 3379, 3380, - 3381, 3382, 3383, 3384, 3385, 3386, 3387, 3388, - 3256, 3389, 3390, 3391, 3392, 3393, 3394, 3395, - 3396, 3397, 3398, 3399, 3400, 3401, 3402, 3403, - 3404, 3405, 3406, 3407, 3408, 3409, 3410, 3411, - 3412, 3413, 3414, 3415, 3416, 3417, 3418, 3419, - 3420, 3421, 3422, 3423, 3424, 3425, 3426, 3427, - 3428, 3429, 3430, 3431, 3432, 3433, 3434, 3435, - 3436, 3437, 3438, 3439, 3440, 3441, 3442, 3443, - 3444, 3445, 3446, 3447, 3448, 3449, 3450, 3451, - 3452, 3453, 3454, 3455, 3456, 3457, 3458, 3459, - 3460, 3461, 3462, 3463, 3464, 3465, 3466, 3467, - 3468, 3469, 3470, 3471, 3472, 3473, 3474, 3475, - 3476, 3477, 3478, 3479, 3480, 3481, 3482, 3483, - 3484, 3485, 3486, 3487, 3488, 3489, 3490, 3491, - 3492, 3493, 3494, 3495, 3496, 3497, 3498, 3499, + 3089, 3090, 3091, 3092, 3093, 3094, 3095, 3096, + 3097, 3098, 3099, 3100, 3101, 3102, 3103, 3104, + 3105, 3106, 3107, 3108, 3109, 3110, 3111, 3112, + 3113, 3114, 3115, 3116, 3117, 3118, 3119, 3120, + 3121, 3122, 3123, 3124, 3125, 3126, 3127, 3128, + 3129, 3130, 3131, 3132, 3133, 3134, 3135, 3136, + 3137, 3138, 3139, 3140, 3141, 3142, 3143, 3144, + 3145, 3146, 3147, 3148, 3149, 3150, 3151, 3152, + 3153, 3154, 3155, 3156, 3157, 3158, 3159, 3160, + 3161, 3162, 3163, 3164, 3165, 3166, 3167, 3168, + 3169, 3170, 3171, 3172, 3173, 3174, 3175, 3176, + 3177, 3178, 3179, 3180, 3181, 3182, 3183, 3184, + 3185, 3186, 3187, 3188, 3189, 3190, 3191, 3192, + 3193, 3194, 3195, 3196, 3197, 3198, 3199, 3200, + 3201, 3202, 3203, 3204, 3205, 3206, 3207, 3208, + 3209, 3210, 3211, 3212, 3213, 3214, 3215, 3216, + 3217, 3218, 3219, 3220, 3221, 3222, 3223, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3007, 3007, 3007, 3007, 3007, 3007, 3007, + 3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, + 3007, 3224, 3225, 3225, 3225, 3007, 3226, 3227, + 3228, 3229, 3230, 3229, 3230, 3229, 3230, 3229, + 3230, 3229, 3230, 3007, 3007, 3229, 3230, 3229, + 3230, 3229, 3230, 3229, 3230, 3231, 3232, 3233, + 3233, 3007, 3228, 3228, 3228, 3228, 3228, 3228, + 3228, 3228, 3228, 1809, 1163, 626, 1162, 3234, + 3234, 3235, 3226, 3226, 3226, 3226, 3226, 3236, + 3007, 3237, 3238, 3239, 3226, 3227, 3240, 3007, + 76, 0, 3227, 3227, 3227, 3227, 3227, 3241, + 3227, 3227, 3227, 3227, 3242, 3243, 3244, 3245, + 3246, 3247, 3248, 3249, 3250, 3251, 3252, 3253, + 3254, 3255, 3256, 3257, 3258, 3259, 3260, 3261, + 3262, 3263, 3264, 3265, 3227, 3266, 3267, 3268, + 3269, 3270, 3271, 3227, 3227, 3227, 3227, 3227, + 3272, 3273, 3274, 3275, 3276, 3277, 3278, 3279, + 3280, 3281, 3282, 3283, 3284, 3285, 3286, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3287, 3227, 3227, + 0, 0, 3288, 3289, 3290, 3291, 3292, 3293, + 3294, 3231, 3227, 3227, 3227, 3227, 3227, 3295, + 3227, 3227, 3227, 3227, 3296, 3297, 3298, 3299, + 3300, 3301, 3302, 3303, 3304, 3305, 3306, 3307, + 3308, 3309, 3310, 3311, 3312, 3313, 3314, 3315, + 3316, 3317, 3318, 3319, 3227, 3320, 3321, 3322, + 3323, 3324, 3325, 3227, 3227, 3227, 3227, 3227, + 3326, 3327, 3328, 3329, 3330, 3331, 3332, 3333, + 3334, 3335, 3336, 3337, 3338, 3339, 3340, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3341, 3342, 3343, 3344, 3227, 3345, 3227, 3227, + 3346, 3347, 3348, 3349, 3225, 3226, 3350, 3351, + 3352, 0, 0, 0, 0, 0, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 0, 3353, 3354, 3355, 3356, 3357, 3358, + 3359, 3360, 3361, 3362, 3363, 3364, 3365, 3366, + 3367, 3368, 3369, 3370, 3371, 3372, 3373, 3374, + 3375, 3376, 3377, 3378, 3379, 3380, 3381, 3382, + 3383, 3384, 3385, 3386, 3387, 3388, 3389, 3390, + 3391, 3392, 3393, 3394, 3395, 3396, 3397, 3398, + 3399, 3400, 3401, 3402, 3403, 3404, 3405, 3406, + 3407, 3408, 3409, 3410, 3411, 3412, 3413, 3414, + 3415, 3416, 3417, 3418, 3419, 3420, 3421, 3422, + 3423, 3424, 3425, 3426, 3427, 3428, 3429, 3430, + 3431, 3432, 3433, 3434, 3435, 3436, 3437, 3438, + 3439, 3440, 3441, 3442, 3443, 3444, 3445, 3446, + 0, 3447, 3447, 3448, 3449, 3450, 3451, 3452, + 3453, 3454, 3455, 3456, 3457, 3458, 3459, 3460, + 3461, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3007, 3007, 3007, 3007, 3007, 3007, 3007, + 3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, + 3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, + 3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, + 3007, 3007, 3007, 3007, 3007, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3007, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3462, 3463, 3464, 3465, 3466, 3467, 3468, + 3469, 3470, 3471, 3472, 3473, 3474, 3475, 3476, + 3477, 3478, 3479, 3480, 3481, 3482, 3483, 3484, + 3485, 3486, 3487, 3488, 3489, 3490, 3491, 3492, + 0, 3493, 3494, 3495, 3496, 3497, 3498, 3499, 3500, 3501, 3502, 3503, 3504, 3505, 3506, 3507, 3508, 3509, 3510, 3511, 3512, 3513, 3514, 3515, 3516, 3517, 3518, 3519, 3520, 3521, 3522, 3523, 3524, 3525, 3526, 3527, 3528, 3529, 3530, 3531, - 3532, 3533, 3534, 3535, 3536, 3537, 3538, 3539, + 3532, 1258, 1258, 1258, 1258, 1258, 1258, 1258, + 1258, 3533, 3534, 3535, 3536, 3537, 3538, 3539, 3540, 3541, 3542, 3543, 3544, 3545, 3546, 3547, 3548, 3549, 3550, 3551, 3552, 3553, 3554, 3555, 3556, 3557, 3558, 3559, 3560, 3561, 3562, 3563, 3564, 3565, 3566, 3567, 3568, 3569, 3570, 3571, 3572, 3573, 3574, 3575, 3576, 3577, 3578, 3579, - 3580, 3581, 3582, 3583, 3584, 3585, 3586, 3587, - 3588, 3589, 3590, 3591, 3592, 3593, 3594, 3595, - 3596, 3597, 3598, 3599, 3600, 3601, 3602, 3603, - 3604, 3605, 3606, 3607, 3608, 3609, 3610, 3611, - 3612, 3613, 3614, 3615, 3616, 3617, 3618, 3619, - 3620, 3621, 3622, 3623, 3624, 3625, 3626, 3627, - 3628, 3629, 3630, 3631, 3632, 3633, 3634, 3635, - 3636, 3637, 3638, 3639, 3640, 3641, 3642, 3643, - 3644, 3645, 3646, 3647, 3648, 3649, 3650, 3651, - 3652, 3653, 3654, 3655, 3656, 3657, 3658, 3659, - 3660, 3661, 3662, 3663, 3664, 3665, 3666, 3667, - 3668, 3669, 3670, 3671, 3672, 3673, 3674, 3675, - 3676, 3677, 3678, 3679, 3680, 3681, 3682, 3683, - 3684, 3685, 3686, 3687, 3688, 3689, 3690, 3691, - 3692, 3693, 3694, 3695, 3696, 3697, 3698, 3699, - 3700, 3701, 3702, 3703, 3704, 3705, 3706, 3707, - 3708, 3709, 3710, 3711, 3712, 3713, 3714, 3715, - 3716, 3717, 3718, 3719, 3720, 3721, 3722, 3723, - 3724, 3725, 3726, 3727, 3728, 3729, 3730, 3731, - 3732, 3733, 3734, 3735, 3736, 3737, 3738, 3739, - 3740, 3741, 3742, 3743, 3744, 3745, 3746, 3747, - 3748, 3749, 3750, 3751, 3752, 3753, 3754, 3755, - 3756, 3757, 3758, 3759, 3760, 3761, 3762, 3763, - 3764, 3765, 3766, 3767, 3768, 3769, 3770, 3771, - 3772, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 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, 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, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3034, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 0, 0, - 0, 2815, 2815, 2815, 2815, 2815, 2815, 2815, - 2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, - 2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, - 2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, - 2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, - 2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, - 2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 525, 525, 525, 525, 525, 525, 1047, - 1047, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 525, 9, 9, - 9, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 341, 341, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 3773, 3774, 3775, 3776, 3777, 3778, 3779, - 3780, 3781, 3782, 3783, 3784, 3785, 3786, 3787, - 3788, 3789, 3790, 3791, 3792, 3793, 3794, 3795, - 3796, 3797, 3798, 3799, 3800, 3801, 3802, 3803, - 3804, 3805, 3806, 3807, 3808, 3809, 3810, 3811, - 3812, 3813, 3814, 3815, 3816, 3817, 3818, 341, - 543, 842, 842, 842, 9, 543, 543, 543, - 543, 543, 543, 543, 543, 543, 543, 9, - 524, 3819, 3820, 3821, 3822, 3823, 3824, 3825, - 3826, 3827, 3828, 3829, 3830, 3831, 3832, 3833, - 3834, 3835, 3836, 3837, 3838, 3839, 3840, 3841, - 3842, 3843, 3844, 3845, 3846, 3847, 3848, 543, - 543, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 1458, - 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, - 1458, 543, 543, 1047, 1047, 1047, 1047, 1047, - 1047, 0, 0, 0, 0, 0, 0, 0, - 0, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, - 524, 524, 524, 524, 524, 524, 524, 524, - 524, 526, 526, 3849, 3850, 3851, 3852, 3853, - 3854, 3855, 3856, 3857, 3858, 3859, 3860, 3861, - 3862, 215, 215, 3863, 3864, 3865, 3866, 3867, - 3868, 3869, 3870, 3871, 3872, 3873, 3874, 3875, - 3876, 3877, 3878, 3879, 3880, 3881, 3882, 3883, - 3884, 3885, 3886, 3887, 3888, 3889, 3890, 3891, - 3892, 3893, 3894, 3895, 3896, 3897, 3898, 3899, - 3900, 3901, 3902, 3903, 3904, 3905, 3906, 3907, - 3908, 3909, 3910, 3911, 3912, 3913, 3914, 3915, - 3916, 3917, 3918, 3919, 3920, 3921, 3922, 3923, - 3924, 3925, 215, 215, 215, 215, 215, 215, - 215, 215, 3926, 3927, 3928, 3929, 3930, 3931, - 3932, 3933, 3934, 3935, 3936, 3937, 3938, 3939, - 3940, 524, 3941, 3941, 3942, 3943, 3944, 215, - 341, 3945, 3946, 3947, 3948, 3949, 215, 3950, - 3951, 3952, 3953, 3954, 3955, 3956, 3957, 3958, - 3959, 3960, 3961, 3962, 3963, 3964, 3965, 3966, - 3967, 3968, 3969, 3970, 3971, 3972, 3973, 3974, - 215, 3975, 3976, 3977, 3978, 3979, 3980, 3981, - 3982, 3983, 3984, 3985, 3986, 3987, 3988, 3989, - 3990, 0, 0, 3991, 3992, 3993, 3994, 3995, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 341, 3996, 3997, 215, 341, 341, 341, 341, - 341, 341, 341, 1151, 341, 341, 341, 1163, - 341, 341, 341, 341, 1151, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 1155, 1155, 1151, 1151, - 1155, 77, 77, 77, 77, 0, 0, 0, - 0, 1182, 1182, 1182, 1182, 1182, 1182, 841, - 841, 11, 84, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 9, 9, 9, - 9, 0, 0, 0, 0, 0, 0, 0, - 0, 1155, 1155, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 1155, 1155, 1155, - 1155, 1155, 1155, 1155, 1155, 1155, 1155, 1155, - 1155, 1155, 1155, 1155, 1155, 1163, 1151, 0, - 0, 0, 0, 0, 0, 0, 0, 1047, - 1047, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 0, 0, 0, 0, 0, - 0, 543, 543, 543, 543, 543, 543, 543, - 543, 543, 543, 543, 543, 543, 543, 543, - 543, 543, 543, 341, 341, 341, 341, 341, - 341, 1047, 1047, 1047, 341, 1047, 341, 341, - 1151, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 1151, - 1151, 1151, 1151, 1151, 556, 556, 556, 1047, - 1047, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, - 1151, 1151, 1151, 1155, 1483, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 1047, 1361, 1361, 1361, 1361, 1361, 1361, 1361, - 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, - 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, - 1361, 1361, 1361, 1361, 1361, 1361, 0, 0, - 0, 1151, 1151, 1151, 1155, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 1173, 1155, 1155, 1151, - 1151, 1151, 1151, 1155, 1155, 1151, 1151, 1155, - 1155, 1483, 1047, 1047, 1047, 1047, 1047, 1047, - 1047, 1047, 1047, 1047, 1047, 1047, 1047, 0, - 525, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 0, 0, 0, 0, 1047, - 1047, 341, 341, 341, 341, 341, 1151, 525, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 341, 341, 341, 341, 341, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 1151, 1151, 1151, 1151, 1151, 1151, - 1155, 1155, 1151, 1151, 1155, 1155, 1151, 1151, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 1151, 341, 341, 341, - 341, 341, 341, 341, 341, 1151, 1155, 0, - 0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 0, 0, 1047, 1047, 1047, - 1047, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 525, 341, 341, 341, 341, 341, 341, - 841, 841, 841, 341, 1272, 1151, 1272, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 543, 341, 543, 543, 556, 341, 341, - 543, 543, 341, 341, 341, 341, 341, 543, - 543, 341, 543, 341, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 341, 341, 525, 1047, - 1047, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 1155, 1151, 1151, 1155, - 1155, 1047, 1047, 341, 525, 525, 1155, 1163, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 341, 341, 341, 341, 341, 341, - 0, 0, 341, 341, 341, 341, 341, 341, - 0, 0, 341, 341, 341, 341, 341, 341, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 0, 341, 341, 341, 341, 341, 341, 341, - 0, 215, 215, 215, 215, 215, 215, 215, - 215, 215, 215, 215, 215, 215, 215, 215, - 215, 215, 215, 215, 215, 215, 215, 215, - 215, 215, 215, 215, 215, 215, 215, 215, - 215, 215, 215, 215, 3998, 215, 215, 215, - 215, 215, 215, 215, 3941, 3999, 4000, 4001, - 4002, 215, 215, 215, 215, 215, 215, 215, - 215, 0, 0, 0, 0, 0, 0, 0, - 0, 4003, 4004, 4005, 4006, 4007, 4008, 4009, - 4010, 4011, 4012, 4013, 4014, 4015, 4016, 4017, - 4018, 4019, 4020, 4021, 4022, 4023, 4024, 4025, - 4026, 4027, 4028, 4029, 4030, 4031, 4032, 4033, - 4034, 4035, 4036, 4037, 4038, 4039, 4040, 4041, - 4042, 4043, 4044, 4045, 4046, 4047, 4048, 4049, - 4050, 4051, 4052, 4053, 4054, 4055, 4056, 4057, - 4058, 4059, 4060, 4061, 4062, 4063, 4064, 4065, - 4066, 4067, 4068, 4069, 4070, 4071, 4072, 4073, - 4074, 4075, 4076, 4077, 4078, 4079, 4080, 4081, - 4082, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 1155, 1155, 1151, 1155, - 1155, 1151, 1155, 1155, 1047, 1155, 1163, 0, - 0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 0, 0, 0, 0, 0, - 0, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, - 4084, 4084, 4084, 4084, 4084, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1364, 1364, 1364, 1364, 1364, 1364, 1364, - 1364, 1364, 1364, 1364, 1364, 1364, 1364, 1364, - 1364, 1364, 1364, 1364, 1364, 1364, 1364, 1364, - 0, 0, 0, 0, 1365, 1365, 1365, 1365, - 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, - 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, - 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, - 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, - 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, - 1365, 1365, 1365, 1365, 1365, 0, 0, 0, - 0, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, - 4085, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4087, 4088, 4089, 4090, 4091, 4092, 4093, - 4094, 4094, 4095, 4096, 4097, 4098, 4099, 4100, + 3447, 3580, 3581, 3582, 3583, 3584, 3585, 3586, + 3587, 3588, 3589, 3590, 3591, 3592, 3593, 3594, + 3595, 3596, 3597, 3598, 3599, 3600, 3601, 3602, + 3603, 3604, 3605, 3606, 3607, 3608, 3609, 3610, + 3611, 3612, 3613, 3614, 3615, 3616, 3617, 3618, + 3619, 3620, 3621, 3622, 3623, 3624, 3625, 3626, + 3627, 3628, 3629, 3630, 3631, 3632, 3633, 3634, + 3635, 3636, 3637, 3638, 3639, 3640, 3641, 3642, + 3643, 3644, 3645, 3646, 3647, 3648, 3649, 3650, + 3651, 3652, 3653, 3654, 3655, 3656, 3657, 3658, + 3659, 3660, 3661, 3662, 3663, 3664, 3665, 3666, + 3667, 3668, 3669, 3670, 3671, 3672, 3673, 3674, + 3675, 3676, 3677, 3678, 3679, 3680, 3681, 3682, + 3683, 3684, 3685, 3686, 3687, 3688, 3689, 3690, + 3691, 3692, 3693, 3694, 3695, 3696, 3697, 3698, + 3699, 3700, 3701, 3702, 3703, 3704, 3705, 3706, + 3707, 3708, 3709, 3710, 3711, 3712, 3713, 3714, + 3715, 3716, 3717, 3718, 3719, 3720, 3721, 3722, + 3723, 3724, 3725, 3726, 3727, 3728, 3729, 3730, + 3731, 3732, 3733, 3734, 3735, 3736, 3737, 3738, + 3739, 3740, 3741, 3742, 3743, 3744, 3745, 3746, + 3747, 3748, 3749, 3750, 3751, 3752, 3753, 3754, + 3755, 3756, 3757, 3758, 3759, 3760, 3761, 3762, + 3763, 3764, 3765, 3766, 3767, 3768, 3769, 3770, + 3771, 3772, 3773, 3774, 3775, 3776, 3777, 3778, + 3779, 3780, 3781, 3782, 3783, 3784, 3785, 3786, + 3787, 3788, 3789, 3790, 3791, 3792, 3793, 3794, + 3795, 3796, 3797, 3798, 3799, 3800, 3801, 3802, + 3803, 3804, 3805, 3806, 3807, 3808, 3809, 3810, + 3811, 3812, 3813, 3814, 3815, 3816, 3817, 3818, + 3819, 3820, 3821, 3822, 3823, 3824, 3825, 3826, + 3827, 3828, 3829, 3830, 3831, 3832, 3833, 3834, + 3835, 3836, 3837, 3838, 3839, 3840, 3841, 3842, + 3843, 3844, 3845, 3846, 3847, 3848, 3849, 3850, + 3851, 3852, 3853, 3854, 3855, 3856, 3857, 3858, + 3859, 3860, 3861, 3862, 3863, 3864, 3865, 3866, + 3867, 3868, 3869, 3870, 3871, 3872, 3873, 3874, + 3875, 3876, 3877, 3878, 3879, 3880, 3881, 3882, + 3883, 3884, 3885, 3886, 3887, 3888, 3889, 3890, + 3891, 3892, 3893, 3894, 3895, 3896, 3897, 3898, + 3899, 3900, 3901, 3902, 3903, 3904, 3905, 3906, + 3907, 3908, 3909, 3910, 3911, 3912, 3913, 3914, + 3915, 3916, 3917, 3918, 3919, 3920, 3921, 3922, + 3923, 3924, 3925, 3926, 3927, 3928, 3929, 3930, + 3931, 3932, 3933, 3934, 3935, 3936, 3937, 3938, + 3939, 3940, 3941, 3942, 3943, 3944, 3945, 3946, + 3947, 3948, 3949, 3950, 3951, 3952, 3953, 3954, + 3955, 3956, 3957, 3958, 3959, 3960, 3961, 3962, + 3963, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 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, 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, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3226, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 0, 0, + 0, 3007, 3007, 3007, 3007, 3007, 3007, 3007, + 3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, + 3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, + 3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, + 3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, + 3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, + 3007, 3007, 3007, 3007, 3007, 3007, 3007, 3007, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 595, 595, 595, 595, 595, 595, 1119, + 1119, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 595, 8, 8, + 8, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 345, 345, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3964, 3965, 3966, 3967, 3968, 3969, 3970, + 3971, 3972, 3973, 3974, 3975, 3976, 3977, 3978, + 3979, 3980, 3981, 3982, 3983, 3984, 3985, 3986, + 3987, 3988, 3989, 3990, 3991, 3992, 3993, 3994, + 3995, 3996, 3997, 3998, 3999, 4000, 4001, 4002, + 4003, 4004, 4005, 4006, 4007, 4008, 4009, 345, + 614, 914, 914, 914, 8, 614, 614, 614, + 614, 614, 614, 614, 614, 614, 614, 8, + 594, 4010, 4011, 4012, 4013, 4014, 4015, 4016, + 4017, 4018, 4019, 4020, 4021, 4022, 4023, 4024, + 4025, 4026, 4027, 4028, 4029, 4030, 4031, 4032, + 4033, 4034, 4035, 4036, 4037, 4038, 4039, 614, + 614, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 1536, + 1536, 1536, 1536, 1536, 1536, 1536, 1536, 1536, + 1536, 614, 614, 1119, 1119, 1119, 1119, 1119, + 1119, 0, 0, 0, 0, 0, 0, 0, + 0, 46, 46, 46, 46, 46, 46, 46, + 46, 46, 46, 46, 46, 46, 46, 46, + 46, 46, 46, 46, 46, 46, 46, 46, + 594, 594, 594, 594, 594, 594, 594, 594, + 594, 46, 46, 4040, 4041, 4042, 4043, 4044, + 4045, 4046, 4047, 4048, 4049, 4050, 4051, 4052, + 4053, 4054, 4055, 4056, 4057, 4058, 4059, 4060, + 4061, 4062, 4063, 4064, 4065, 4066, 4067, 4068, + 4069, 4070, 4071, 4072, 4073, 4074, 4075, 4076, + 4077, 4078, 4079, 4080, 4081, 4082, 4083, 4084, + 4085, 4086, 4087, 4088, 4089, 4090, 4091, 4092, + 4093, 4094, 4095, 4096, 4097, 4098, 4099, 4100, 4101, 4102, 4103, 4104, 4105, 4106, 4107, 4108, 4109, 4110, 4111, 4112, 4113, 4114, 4115, 4116, 4117, 4118, 4119, 4120, 4121, 4122, 4123, 4124, 4125, 4126, 4127, 4128, 4129, 4130, 4131, 4132, 4133, 4134, 4135, 4136, 4137, 4138, 4139, 4140, - 4141, 4142, 4143, 4144, 4145, 4146, 4147, 4148, - 4149, 4150, 4151, 4152, 4153, 4154, 4155, 4156, - 4157, 4158, 4159, 4160, 4161, 4162, 4163, 4164, - 4165, 4166, 4167, 4168, 4169, 4170, 4171, 4172, - 4173, 4174, 4175, 4176, 4177, 4106, 4178, 4179, - 4180, 4181, 4182, 4183, 4184, 4185, 4186, 4187, - 4188, 4189, 4190, 4191, 4192, 4193, 4194, 4195, - 4196, 4197, 4198, 4199, 4200, 4201, 4202, 4203, - 4204, 4205, 4206, 4207, 4208, 4209, 4210, 4211, - 4212, 4213, 4214, 4215, 4216, 4217, 4218, 4219, - 4220, 4221, 4222, 4223, 4224, 4225, 4226, 4227, - 4228, 4229, 4230, 4231, 4232, 4233, 4234, 4235, - 4236, 4237, 4238, 4239, 4240, 4241, 4242, 4243, - 4244, 4245, 4196, 4246, 4247, 4248, 4249, 4250, - 4251, 4252, 4253, 4180, 4254, 4255, 4256, 4257, - 4258, 4259, 4260, 4261, 4262, 4263, 4264, 4265, - 4266, 4267, 4268, 4269, 4270, 4271, 4272, 4273, - 4106, 4274, 4275, 4276, 4277, 4278, 4279, 4280, - 4281, 4282, 4283, 4284, 4285, 4286, 4287, 4288, - 4289, 4290, 4291, 4292, 4293, 4294, 4295, 4296, - 4297, 4298, 4299, 4300, 4182, 4301, 4302, 4303, - 4304, 4305, 4306, 4307, 4308, 4309, 4310, 4311, - 4312, 4313, 4314, 4315, 4316, 4317, 4318, 4319, - 4320, 4321, 4322, 4323, 4324, 4325, 4326, 4327, - 4328, 4329, 4330, 4331, 4332, 4333, 4334, 4335, - 4336, 4337, 4338, 4339, 4340, 4341, 4342, 4343, - 4344, 4345, 4346, 4347, 4348, 4349, 4350, 3035, - 3035, 4351, 3035, 4352, 3035, 3035, 4353, 4354, - 4355, 4356, 4357, 4358, 4359, 4360, 4361, 4362, - 3035, 4363, 3035, 4364, 3035, 3035, 4365, 4366, - 3035, 3035, 3035, 4367, 4368, 4369, 4370, 4371, - 4372, 4373, 4374, 4375, 4376, 4377, 4378, 4379, - 4380, 4381, 4382, 4383, 4384, 4385, 4386, 4387, - 4388, 4389, 4390, 4391, 4392, 4393, 4394, 4395, - 4396, 4397, 4398, 4399, 4400, 4401, 4402, 4403, - 4404, 4405, 4406, 4407, 4408, 4409, 4410, 4411, - 4235, 4412, 4413, 4414, 4415, 4416, 4417, 4417, - 4418, 4419, 4420, 4421, 4422, 4423, 4424, 4425, - 4365, 4426, 4427, 4428, 4429, 4430, 4431, 0, - 0, 4432, 4433, 4434, 4435, 4436, 4437, 4438, - 4439, 4379, 4440, 4441, 4442, 4351, 4443, 4444, - 4445, 4446, 4447, 4448, 4449, 4450, 4451, 4452, - 4453, 4454, 4388, 4455, 4389, 4456, 4457, 4458, - 4459, 4460, 4352, 4127, 4461, 4462, 4463, 4197, - 4284, 4464, 4465, 4396, 4466, 4397, 4467, 4468, - 4469, 4354, 4470, 4471, 4472, 4473, 4474, 4355, - 4475, 4476, 4477, 4478, 4479, 4480, 4411, 4481, - 4482, 4235, 4483, 4415, 4484, 4485, 4486, 4487, - 4488, 4420, 4489, 4364, 4490, 4421, 4178, 4491, - 4422, 4492, 4424, 4493, 4494, 4495, 4496, 4497, - 4426, 4360, 4498, 4427, 4499, 4428, 4500, 4094, - 4501, 4502, 4503, 4504, 4505, 4506, 4507, 4508, - 4509, 4510, 4511, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 4512, 4513, 4514, 4515, 4516, 4517, 4518, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 4519, 4520, 4521, 4522, - 4523, 0, 0, 0, 0, 0, 4524, 4525, - 4526, 4527, 4528, 4529, 4530, 4531, 4532, 4533, + 4141, 594, 4142, 4142, 4143, 4144, 4145, 4146, + 345, 4147, 4148, 4149, 4150, 4151, 4152, 4153, + 4154, 4155, 4156, 4157, 4158, 4159, 4160, 4161, + 4162, 4163, 4164, 4165, 4166, 4167, 4168, 4169, + 4170, 4171, 4172, 4173, 4174, 4175, 4176, 4177, + 4178, 4179, 4180, 4181, 4182, 4183, 4184, 4185, + 4186, 4187, 4188, 4189, 4190, 4191, 4192, 4193, + 4194, 4195, 4196, 4197, 4198, 4199, 4200, 4201, + 4202, 4203, 4204, 4205, 0, 0, 0, 0, + 0, 4206, 4207, 0, 4208, 0, 4209, 4210, + 4211, 4212, 4213, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 4214, 4215, 4216, 4217, 4218, + 345, 4219, 4220, 4221, 345, 345, 345, 345, + 345, 345, 345, 1225, 345, 345, 345, 1261, + 345, 345, 345, 345, 1225, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 1230, 1230, 1225, 1225, + 1230, 76, 76, 76, 76, 1299, 0, 0, + 0, 1258, 1258, 1258, 1258, 1258, 1258, 913, + 913, 10, 83, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 8, 8, 8, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 1230, 1230, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 1230, 1230, 1230, + 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, + 1230, 1230, 1230, 1230, 1230, 1261, 1225, 0, + 0, 0, 0, 0, 0, 0, 0, 1119, + 1119, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 0, 0, 0, 0, 0, + 0, 614, 614, 614, 614, 614, 614, 614, + 614, 614, 614, 614, 614, 614, 614, 614, + 614, 614, 614, 345, 345, 345, 345, 345, + 345, 1119, 1119, 1119, 345, 1119, 345, 345, + 1225, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 1225, + 1225, 1225, 1225, 1225, 627, 627, 627, 1119, + 1119, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 1225, 1225, 1230, 1537, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1119, 1439, 1439, 1439, 1439, 1439, 1439, 1439, + 1439, 1439, 1439, 1439, 1439, 1439, 1439, 1439, + 1439, 1439, 1439, 1439, 1439, 1439, 1439, 1439, + 1439, 1439, 1439, 1439, 1439, 1439, 0, 0, + 0, 1225, 1225, 1225, 1230, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 1249, 1230, 1230, 1225, + 1225, 1225, 1225, 1230, 1230, 1225, 1225, 1230, + 1230, 1537, 1119, 1119, 1119, 1119, 1119, 1119, + 1119, 1119, 1119, 1119, 1119, 1119, 1119, 0, + 595, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 0, 0, 0, 0, 1119, + 1119, 345, 345, 345, 345, 345, 1225, 595, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 345, 345, 345, 345, 345, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 1225, 1225, 1225, 1225, 1225, 1225, + 1230, 1230, 1225, 1225, 1230, 1230, 1225, 1225, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 1225, 345, 345, 345, + 345, 345, 345, 345, 345, 1225, 1230, 0, + 0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 0, 0, 1119, 1119, 1119, + 1119, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 595, 345, 345, 345, 345, 345, 345, + 913, 913, 913, 345, 1350, 1225, 1350, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 614, 345, 614, 614, 627, 345, 345, + 614, 614, 345, 345, 345, 345, 345, 614, + 614, 345, 614, 345, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 345, 345, 595, 1119, + 1119, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 1230, 1225, 1225, 1230, + 1230, 1119, 1119, 345, 595, 595, 1230, 1299, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 345, 345, 345, 345, 345, 345, + 0, 0, 345, 345, 345, 345, 345, 345, + 0, 0, 345, 345, 345, 345, 345, 345, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 0, 345, 345, 345, 345, 345, 345, 345, + 0, 4222, 4223, 4224, 4225, 4226, 4227, 4228, + 4229, 4230, 4231, 4232, 4233, 4234, 4235, 4236, + 4237, 4238, 4239, 4240, 4241, 4242, 4243, 4244, + 4245, 4246, 4247, 4248, 4249, 4250, 4251, 4252, + 4253, 4254, 4255, 4256, 4257, 4258, 4259, 4260, + 4261, 4262, 4263, 4264, 4142, 4265, 4266, 4267, + 4268, 4269, 4270, 4271, 4272, 4273, 4274, 4275, + 4276, 4277, 4278, 46, 46, 0, 0, 0, + 0, 4279, 4280, 4281, 4282, 4283, 4284, 4285, + 4286, 4287, 4288, 4289, 4290, 4291, 4292, 4293, + 4294, 4295, 4296, 4297, 4298, 4299, 4300, 4301, + 4302, 4303, 4304, 4305, 4306, 4307, 4308, 4309, + 4310, 4311, 4312, 4313, 4314, 4315, 4316, 4317, + 4318, 4319, 4320, 4321, 4322, 4323, 4324, 4325, + 4326, 4327, 4328, 4329, 4330, 4331, 4332, 4333, + 4334, 4335, 4336, 4337, 4338, 4339, 4340, 4341, + 4342, 4343, 4344, 4345, 4346, 4347, 4348, 4349, + 4350, 4351, 4352, 4353, 4354, 4355, 4356, 4357, + 4358, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 1230, 1230, 1225, 1230, + 1230, 1225, 1230, 1230, 1119, 1230, 1299, 0, + 0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 0, 0, 0, 0, 0, + 0, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4359, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4359, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 4360, 4360, 4360, + 4360, 4360, 4360, 4360, 4360, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1442, 1442, 1442, 1442, 1442, 1442, 1442, + 1442, 1442, 1442, 1442, 1442, 1442, 1442, 1442, + 1442, 1442, 1442, 1442, 1442, 1442, 1442, 1442, + 0, 0, 0, 0, 1443, 1443, 1443, 1443, + 1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, + 1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, + 1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, + 1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, + 1443, 1443, 1443, 1443, 1443, 1443, 1443, 1443, + 1443, 1443, 1443, 1443, 1443, 0, 0, 0, + 0, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4361, 4361, 4361, 4361, 4361, 4361, 4361, + 4361, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4363, 4364, 4365, 4366, 4367, 4368, 4369, + 4370, 4370, 4371, 4372, 4373, 4374, 4375, 4376, + 4377, 4378, 4379, 4380, 4381, 4382, 4383, 4384, + 4385, 4386, 4387, 4388, 4389, 4390, 4391, 4392, + 4393, 4394, 4395, 4396, 4397, 4398, 4399, 4400, + 4401, 4402, 4403, 4404, 4405, 4406, 4407, 4408, + 4409, 4410, 4411, 4412, 4413, 4414, 4415, 4416, + 4417, 4418, 4419, 4420, 4421, 4422, 4423, 4424, + 4425, 4426, 4427, 4428, 4429, 4430, 4431, 4432, + 4433, 4434, 4435, 4436, 4437, 4438, 4439, 4440, + 4441, 4442, 4443, 4444, 4445, 4446, 4447, 4448, + 4449, 4450, 4451, 4452, 4453, 4382, 4454, 4455, + 4456, 4457, 4458, 4459, 4460, 4461, 4462, 4463, + 4464, 4465, 4466, 4467, 4468, 4469, 4470, 4471, + 4472, 4473, 4474, 4475, 4476, 4477, 4478, 4479, + 4480, 4481, 4482, 4483, 4484, 4485, 4486, 4487, + 4488, 4489, 4490, 4491, 4492, 4493, 4494, 4495, + 4496, 4497, 4498, 4499, 4500, 4501, 4502, 4503, + 4504, 4505, 4506, 4507, 4508, 4509, 4510, 4511, + 4512, 4513, 4514, 4515, 4516, 4517, 4518, 4519, + 4520, 4521, 4472, 4522, 4523, 4524, 4525, 4526, + 4527, 4528, 4529, 4456, 4530, 4531, 4532, 4533, 4534, 4535, 4536, 4537, 4538, 4539, 4540, 4541, 4542, 4543, 4544, 4545, 4546, 4547, 4548, 4549, - 0, 4550, 4551, 4552, 4553, 4554, 0, 4555, - 0, 4556, 4557, 0, 4558, 4559, 0, 4560, - 4561, 4562, 4563, 4564, 4565, 4566, 4567, 4568, - 4569, 4570, 4571, 4572, 4573, 4574, 4575, 4576, - 4577, 4578, 4579, 4580, 4581, 4582, 4583, 4584, - 4585, 4586, 4587, 4588, 4589, 4590, 4591, 4592, - 4593, 4594, 4595, 4596, 4597, 4598, 4599, 4600, - 4601, 4602, 4603, 4604, 4605, 4606, 4607, 4608, - 4609, 4610, 4611, 4612, 4613, 4614, 4615, 4616, - 4617, 4618, 4619, 4620, 4621, 4622, 4623, 4624, - 4625, 4626, 4627, 4628, 4629, 4630, 4631, 4632, - 4633, 4634, 4635, 4636, 4637, 4638, 4639, 4640, - 4641, 4642, 4643, 4644, 4645, 4646, 4647, 4648, - 4649, 4650, 4651, 4652, 4653, 4654, 4655, 4656, - 4657, 4658, 4659, 4660, 4661, 4662, 4663, 4664, - 4665, 4666, 4667, 4668, 4668, 4668, 4668, 4668, - 4668, 4668, 4668, 4668, 4668, 4668, 4668, 4668, - 4668, 4668, 4668, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 4669, 4670, 4671, 4672, - 4673, 4674, 4675, 4676, 4677, 4678, 4679, 4680, - 4681, 4682, 4683, 4684, 4685, 4686, 4687, 4688, - 4689, 4690, 4691, 4692, 4693, 4694, 4695, 4696, - 4697, 4698, 4699, 4700, 4701, 4702, 4703, 4704, - 4705, 4706, 4707, 4708, 4709, 4710, 4711, 4712, - 4713, 4714, 4715, 4716, 4707, 4717, 4718, 4719, - 4720, 4721, 4722, 4723, 4724, 4725, 4726, 4727, - 4728, 4729, 4730, 4731, 4732, 4733, 4734, 4735, - 4736, 4737, 4738, 4739, 4740, 4741, 4742, 4743, - 4744, 4745, 4746, 4747, 4748, 4749, 4750, 4751, - 4752, 4753, 4754, 4755, 4756, 4757, 4758, 4759, - 4760, 4761, 4762, 4763, 4764, 4765, 4766, 4767, - 4768, 4769, 4770, 4771, 4772, 4773, 4774, 4775, - 4776, 4777, 4778, 4779, 4780, 4781, 4782, 4783, - 4784, 4785, 4786, 4787, 4788, 4789, 4790, 4791, - 4792, 4793, 4794, 4795, 4796, 4797, 4798, 4799, - 4800, 4801, 4802, 4803, 4804, 4805, 4806, 4807, - 4808, 4809, 4810, 4811, 4812, 4813, 4814, 4815, - 4816, 4708, 4817, 4818, 4819, 4820, 4821, 4822, - 4823, 4824, 4825, 4826, 4827, 4828, 4829, 4830, - 4831, 4832, 4833, 4834, 4835, 4836, 4837, 4838, - 4839, 4840, 4841, 4842, 4843, 4844, 4845, 4846, - 4847, 4848, 4849, 4850, 4851, 4852, 4853, 4854, - 4855, 4856, 4857, 4858, 4859, 4860, 4861, 4862, - 4863, 4864, 4865, 4866, 4867, 4868, 4869, 4870, - 4871, 4872, 4873, 4874, 4875, 4876, 4877, 4878, - 4879, 4880, 4881, 4882, 4883, 4884, 4885, 4886, - 4887, 4888, 4889, 4890, 4891, 4892, 4893, 4894, - 4895, 4896, 4897, 4898, 4899, 4900, 4901, 4902, - 4903, 4904, 4905, 4906, 4907, 4908, 4909, 4910, - 4911, 4912, 4913, 4914, 4915, 4916, 4917, 4918, - 4919, 4920, 4921, 4922, 4923, 4924, 4925, 4926, - 4927, 4928, 4929, 4930, 4931, 4932, 4933, 4934, - 4935, 4936, 4937, 4938, 4939, 4940, 4941, 4942, - 4943, 4944, 4945, 4946, 4947, 4948, 4949, 4950, - 4951, 4952, 4953, 4954, 4955, 4956, 4957, 4958, - 4959, 4960, 4961, 4962, 4963, 4964, 4965, 4966, - 4967, 4968, 4969, 4970, 4971, 4972, 4973, 4974, - 4975, 4976, 4977, 4978, 4979, 4980, 4981, 4982, - 4983, 4984, 4985, 4986, 4987, 4988, 4989, 4990, - 4991, 4992, 4993, 4994, 4995, 4996, 4997, 4998, - 4999, 5000, 5001, 5002, 5003, 5004, 5005, 5006, - 5007, 5008, 5009, 5010, 5011, 5012, 5013, 5014, - 5015, 5016, 5017, 5018, 5019, 5020, 5021, 5022, - 5023, 5024, 5025, 5026, 5027, 5028, 5029, 5030, - 2137, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 5031, 5032, 5033, 5034, 5035, 5036, 5037, - 5038, 5039, 5040, 5041, 5042, 5043, 5044, 5045, - 5046, 5047, 5048, 5049, 5050, 5051, 5052, 5053, - 5054, 5055, 5056, 5057, 5058, 5059, 5060, 5061, - 5062, 5063, 5064, 5065, 5066, 5067, 5068, 5069, - 5070, 5071, 5072, 5073, 5074, 5075, 5076, 5077, - 5078, 5079, 5080, 5081, 5082, 5083, 5084, 5085, - 5086, 5087, 5088, 5089, 5090, 5091, 5092, 5093, - 5094, 0, 0, 5095, 5096, 5097, 5098, 5099, - 5100, 5101, 5102, 5103, 5104, 5105, 5106, 5107, - 5108, 5109, 5110, 5111, 5112, 5113, 5114, 5115, - 5116, 5117, 5118, 5119, 5120, 5121, 5122, 5123, - 5124, 5125, 5126, 5127, 5128, 5129, 5130, 5131, - 5132, 5133, 5134, 5135, 5136, 5137, 5138, 5139, - 5140, 5141, 5142, 5143, 5144, 5145, 5146, 5147, - 5148, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 5149, 5150, 5151, 5152, 5153, 5154, 5155, - 5156, 5157, 5158, 5159, 5160, 5161, 77, 0, - 0, 577, 577, 577, 577, 577, 577, 577, - 577, 577, 577, 577, 577, 577, 577, 577, - 577, 5162, 5163, 5164, 5165, 5166, 5167, 5168, - 5169, 5170, 5171, 0, 0, 0, 0, 0, - 0, 543, 543, 543, 543, 543, 543, 543, - 556, 556, 556, 556, 556, 556, 556, 543, - 543, 5172, 5173, 5174, 5175, 5175, 5176, 5177, + 4382, 4550, 4551, 4552, 4553, 4554, 4555, 4556, + 4557, 4558, 4559, 4560, 4561, 4562, 4563, 4564, + 4565, 4566, 4567, 4568, 4569, 4570, 4571, 4572, + 4573, 4574, 4575, 4576, 4458, 4577, 4578, 4579, + 4580, 4581, 4582, 4583, 4584, 4585, 4586, 4587, + 4588, 4589, 4590, 4591, 4592, 4593, 4594, 4595, + 4596, 4597, 4598, 4599, 4600, 4601, 4602, 4603, + 4604, 4605, 4606, 4607, 4608, 4609, 4610, 4611, + 4612, 4613, 4614, 4615, 4616, 4617, 4618, 4619, + 4620, 4621, 4622, 4623, 4624, 4625, 4626, 3227, + 3227, 4627, 3227, 4628, 3227, 3227, 4629, 4630, + 4631, 4632, 4633, 4634, 4635, 4636, 4637, 4638, + 3227, 4639, 3227, 4640, 3227, 3227, 4641, 4642, + 3227, 3227, 3227, 4643, 4644, 4645, 4646, 4647, + 4648, 4649, 4650, 4651, 4652, 4653, 4654, 4655, + 4656, 4657, 4658, 4659, 4660, 4661, 4662, 4663, + 4664, 4665, 4666, 4667, 4668, 4669, 4670, 4671, + 4672, 4673, 4674, 4675, 4676, 4677, 4678, 4679, + 4680, 4681, 4682, 4683, 4684, 4685, 4686, 4687, + 4511, 4688, 4689, 4690, 4691, 4692, 4693, 4693, + 4694, 4695, 4696, 4697, 4698, 4699, 4700, 4701, + 4641, 4702, 4703, 4704, 4705, 4706, 4707, 0, + 0, 4708, 4709, 4710, 4711, 4712, 4713, 4714, + 4715, 4655, 4716, 4717, 4718, 4627, 4719, 4720, + 4721, 4722, 4723, 4724, 4725, 4726, 4727, 4728, + 4729, 4730, 4664, 4731, 4665, 4732, 4733, 4734, + 4735, 4736, 4628, 4403, 4737, 4738, 4739, 4473, + 4560, 4740, 4741, 4672, 4742, 4673, 4743, 4744, + 4745, 4630, 4746, 4747, 4748, 4749, 4750, 4631, + 4751, 4752, 4753, 4754, 4755, 4756, 4687, 4757, + 4758, 4511, 4759, 4691, 4760, 4761, 4762, 4763, + 4764, 4696, 4765, 4640, 4766, 4697, 4454, 4767, + 4698, 4768, 4700, 4769, 4770, 4771, 4772, 4773, + 4702, 4636, 4774, 4703, 4775, 4704, 4776, 4370, + 4777, 4778, 4779, 4780, 4781, 4782, 4783, 4784, + 4785, 4786, 4787, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 4788, 4789, 4790, 4791, 4792, 4793, 4794, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 4795, 4796, 4797, 4798, + 4799, 0, 0, 0, 0, 0, 4800, 4801, + 4802, 4803, 4804, 4805, 4806, 4807, 4808, 4809, + 4810, 4811, 4812, 4813, 4814, 4815, 4816, 4817, + 4818, 4819, 4820, 4821, 4822, 4823, 4824, 4825, + 0, 4826, 4827, 4828, 4829, 4830, 0, 4831, + 0, 4832, 4833, 0, 4834, 4835, 0, 4836, + 4837, 4838, 4839, 4840, 4841, 4842, 4843, 4844, + 4845, 4846, 4847, 4848, 4849, 4850, 4851, 4852, + 4853, 4854, 4855, 4856, 4857, 4858, 4859, 4860, + 4861, 4862, 4863, 4864, 4865, 4866, 4867, 4868, + 4869, 4870, 4871, 4872, 4873, 4874, 4875, 4876, + 4877, 4878, 4879, 4880, 4881, 4882, 4883, 4884, + 4885, 4886, 4887, 4888, 4889, 4890, 4891, 4892, + 4893, 4894, 4895, 4896, 4897, 4898, 4899, 4900, + 4901, 4902, 4903, 4904, 4905, 4906, 4907, 4908, + 4909, 4910, 4911, 4912, 4913, 4914, 4915, 4916, + 4917, 4918, 4919, 4920, 4921, 4922, 4923, 4924, + 4925, 4926, 4927, 4928, 4929, 4930, 4931, 4932, + 4933, 4934, 4935, 4936, 4937, 4938, 4939, 4940, + 4941, 4942, 4943, 1229, 1229, 1229, 1229, 1229, + 1229, 1229, 1229, 1229, 1229, 1229, 1229, 1229, + 1229, 1229, 1229, 1229, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 4944, 4945, 4946, 4947, + 4948, 4949, 4950, 4951, 4952, 4953, 4954, 4955, + 4956, 4957, 4958, 4959, 4960, 4961, 4962, 4963, + 4964, 4965, 4966, 4967, 4968, 4969, 4970, 4971, + 4972, 4973, 4974, 4975, 4976, 4977, 4978, 4979, + 4980, 4981, 4982, 4983, 4984, 4985, 4986, 4987, + 4988, 4989, 4990, 4991, 4982, 4992, 4993, 4994, + 4995, 4996, 4997, 4998, 4999, 5000, 5001, 5002, + 5003, 5004, 5005, 5006, 5007, 5008, 5009, 5010, + 5011, 5012, 5013, 5014, 5015, 5016, 5017, 5018, + 5019, 5020, 5021, 5022, 5023, 5024, 5025, 5026, + 5027, 5028, 5029, 5030, 5031, 5032, 5033, 5034, + 5035, 5036, 5037, 5038, 5039, 5040, 5041, 5042, + 5043, 5044, 5045, 5046, 5047, 5048, 5049, 5050, + 5051, 5052, 5053, 5054, 5055, 5056, 5057, 5058, + 5059, 5060, 5061, 5062, 5063, 5064, 5065, 5066, + 5067, 5068, 5069, 5070, 5071, 5072, 5073, 5074, + 5075, 5076, 5077, 5078, 5079, 5080, 5081, 5082, + 5083, 5084, 5085, 5086, 5087, 5088, 5089, 5090, + 5091, 4983, 5092, 5093, 5094, 5095, 5096, 5097, + 5098, 5099, 5100, 5101, 5102, 5103, 5104, 5105, + 5106, 5107, 5108, 5109, 5110, 5111, 5112, 5113, + 5114, 5115, 5116, 5117, 5118, 5119, 5120, 5121, + 5122, 5123, 5124, 5125, 5126, 5127, 5128, 5129, + 5130, 5131, 5132, 5133, 5134, 5135, 5136, 5137, + 5138, 5139, 5140, 5141, 5142, 5143, 5144, 5145, + 5146, 5147, 5148, 5149, 5150, 5151, 5152, 5153, + 5154, 5155, 5156, 5157, 5158, 5159, 5160, 5161, + 5162, 5163, 5164, 5165, 5166, 5167, 5168, 5169, + 5170, 5171, 5172, 5173, 5174, 5175, 5176, 5177, 5178, 5179, 5180, 5181, 5182, 5183, 5184, 5185, - 5186, 5187, 5188, 5189, 5190, 5191, 3033, 3033, - 5192, 5193, 5194, 5194, 5194, 5194, 5195, 5195, - 5195, 5196, 5197, 5198, 0, 5199, 5200, 5201, + 5186, 5187, 5188, 5189, 5190, 5191, 5192, 5193, + 5194, 5195, 5196, 5197, 5198, 5199, 5200, 5201, 5202, 5203, 5204, 5205, 5206, 5207, 5208, 5209, 5210, 5211, 5212, 5213, 5214, 5215, 5216, 5217, - 0, 5218, 5219, 5220, 5221, 0, 0, 0, - 0, 5222, 5223, 5224, 1117, 5225, 0, 5226, - 5227, 5228, 5229, 5230, 5231, 5232, 5233, 5234, - 5235, 5236, 5237, 5238, 5239, 5240, 5241, 5242, - 5243, 5244, 5245, 5246, 5247, 5248, 5249, 5250, - 5251, 5252, 5253, 5254, 5255, 5256, 5257, 5258, - 5259, 5260, 5261, 5262, 5263, 5264, 5265, 5266, - 5267, 5268, 5269, 5270, 5271, 5272, 5273, 5274, - 5275, 5276, 5277, 5278, 5279, 5280, 5281, 5282, - 5283, 5284, 5285, 5286, 5287, 5288, 5289, 5290, - 5291, 5292, 5293, 5294, 5295, 5296, 5297, 5298, - 5299, 5300, 5301, 5302, 5303, 5304, 5305, 5306, - 5307, 5308, 5309, 5310, 5311, 5312, 5313, 5314, - 5315, 5316, 5317, 5318, 5319, 5320, 5321, 5322, - 5323, 5324, 5325, 5326, 5327, 5328, 5329, 5330, - 5331, 5332, 5333, 5334, 5335, 5336, 5337, 5338, - 5339, 5340, 5341, 5342, 5343, 5344, 5345, 5346, - 5347, 5348, 5349, 5350, 5351, 5352, 5353, 5354, - 5355, 5356, 5357, 5358, 5359, 5360, 0, 0, - 1459, 0, 5361, 5362, 5363, 5364, 5365, 5366, - 5367, 5368, 5369, 5370, 5371, 5372, 5373, 5374, + 5218, 5219, 5220, 5221, 5222, 5223, 5224, 5225, + 5226, 5227, 5228, 5229, 5230, 5231, 5232, 5233, + 5234, 5235, 5236, 5237, 5238, 5239, 5240, 5241, + 5242, 5243, 5244, 5245, 5246, 5247, 5248, 5249, + 5250, 5251, 5252, 5253, 5254, 5255, 5256, 5257, + 5258, 5259, 5260, 5261, 5262, 5263, 5264, 5265, + 5266, 5267, 5268, 5269, 5270, 5271, 5272, 5273, + 5274, 5275, 5276, 5277, 5278, 5279, 5280, 5281, + 5282, 5283, 5284, 5285, 5286, 5287, 5288, 5289, + 5290, 5291, 5292, 5293, 5294, 5295, 5296, 5297, + 5298, 5299, 5300, 5301, 5302, 5303, 5304, 5305, + 2311, 76, 76, 76, 76, 76, 76, 76, + 76, 76, 76, 76, 76, 76, 76, 76, + 76, 5306, 5307, 5308, 5309, 5310, 5311, 5312, + 5313, 5314, 5315, 5316, 5317, 5318, 5319, 5320, + 5321, 5322, 5323, 5324, 5325, 5326, 5327, 5328, + 5329, 5330, 5331, 5332, 5333, 5334, 5335, 5336, + 5337, 5338, 5339, 5340, 5341, 5342, 5343, 5344, + 5345, 5346, 5347, 5348, 5349, 5350, 5351, 5352, + 5353, 5354, 5355, 5356, 5357, 5358, 5359, 5360, + 5361, 5362, 5363, 5364, 5365, 5366, 5367, 5368, + 5369, 0, 0, 5370, 5371, 5372, 5373, 5374, 5375, 5376, 5377, 5378, 5379, 5380, 5381, 5382, 5383, 5384, 5385, 5386, 5387, 5388, 5389, 5390, 5391, 5392, 5393, 5394, 5395, 5396, 5397, 5398, 5399, 5400, 5401, 5402, 5403, 5404, 5405, 5406, 5407, 5408, 5409, 5410, 5411, 5412, 5413, 5414, 5415, 5416, 5417, 5418, 5419, 5420, 5421, 5422, - 5423, 5424, 5425, 5426, 5427, 5428, 5429, 5430, - 5431, 5432, 5433, 5434, 5435, 5436, 5437, 5438, - 5439, 5440, 5441, 5442, 5443, 5444, 5445, 5446, - 5447, 5448, 5449, 5450, 5451, 5452, 5453, 5454, - 5455, 5456, 5457, 5458, 5459, 5460, 5461, 5462, - 5463, 5464, 5465, 5466, 5467, 5468, 5469, 5470, - 5471, 5472, 5473, 5474, 5475, 5476, 5477, 5478, - 5479, 5480, 5481, 5482, 5483, 5484, 5485, 5486, - 5487, 5488, 5489, 5490, 5491, 5492, 5493, 5494, - 5495, 5496, 5497, 5498, 5499, 5500, 5501, 5502, - 5503, 5504, 5505, 5506, 5507, 5508, 5509, 5510, - 5511, 5512, 5513, 5514, 5515, 5516, 5517, 5518, - 5519, 5520, 5521, 5522, 5523, 5524, 5525, 5526, - 5527, 5528, 5529, 5530, 5531, 5532, 5533, 5534, - 5535, 5536, 5537, 5538, 5539, 5540, 5541, 5542, - 5543, 5544, 5545, 5546, 5547, 5548, 5549, 5550, - 0, 0, 0, 5551, 5552, 5553, 5554, 5555, - 5556, 0, 0, 5557, 5558, 5559, 5560, 5561, - 5562, 0, 0, 5563, 5564, 5565, 5566, 5567, - 5568, 0, 0, 5569, 5570, 5571, 0, 0, - 0, 5572, 5573, 5574, 5575, 5576, 5577, 5578, - 0, 5579, 5580, 5581, 5582, 5583, 5584, 5585, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 5586, 5586, 5586, 77, 77, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 0, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 0, 341, 341, 0, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 0, 0, 0, 0, - 0, 1047, 9, 1047, 0, 0, 0, 0, + 5423, 0, 0, 0, 0, 0, 0, 0, + 76, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 5424, 5425, 5426, 5427, 5428, 5429, 5430, + 5431, 5432, 5433, 5434, 5435, 5436, 76, 76, + 76, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, + 648, 5437, 5438, 5439, 5440, 5441, 5442, 5443, + 5444, 5445, 5446, 0, 0, 0, 0, 0, + 0, 614, 614, 614, 614, 614, 614, 614, + 627, 627, 627, 627, 627, 627, 627, 614, + 614, 5447, 5448, 5449, 5450, 5450, 5451, 5452, + 5453, 5454, 5455, 5456, 5457, 5458, 5459, 5460, + 5461, 5462, 5463, 5464, 5465, 5466, 3225, 3225, + 5467, 5468, 5469, 5469, 5469, 5469, 5470, 5470, + 5470, 5471, 5472, 5473, 0, 5474, 5475, 5476, + 5477, 5478, 5479, 5480, 5481, 5482, 5483, 5484, + 5485, 5486, 5487, 5488, 5489, 5490, 5491, 5492, + 0, 5493, 5494, 5495, 5496, 0, 0, 0, + 0, 5497, 5498, 5499, 1191, 5500, 0, 5501, + 5502, 5503, 5504, 5505, 5506, 5507, 5508, 5509, + 5510, 5511, 5512, 5513, 5514, 5515, 5516, 5517, + 5518, 5519, 5520, 5521, 5522, 5523, 5524, 5525, + 5526, 5527, 5528, 5529, 5530, 5531, 5532, 5533, + 5534, 5535, 5536, 5537, 5538, 5539, 5540, 5541, + 5542, 5543, 5544, 5545, 5546, 5547, 5548, 5549, + 5550, 5551, 5552, 5553, 5554, 5555, 5556, 5557, + 5558, 5559, 5560, 5561, 5562, 5563, 5564, 5565, + 5566, 5567, 5568, 5569, 5570, 5571, 5572, 5573, + 5574, 5575, 5576, 5577, 5578, 5579, 5580, 5581, + 5582, 5583, 5584, 5585, 5586, 5587, 5588, 5589, + 5590, 5591, 5592, 5593, 5594, 5595, 5596, 5597, + 5598, 5599, 5600, 5601, 5602, 5603, 5604, 5605, + 5606, 5607, 5608, 5609, 5610, 5611, 5612, 5613, + 5614, 5615, 5616, 5617, 5618, 5619, 5620, 5621, + 5622, 5623, 5624, 5625, 5626, 5627, 5628, 5629, + 5630, 5631, 5632, 5633, 5634, 5635, 0, 0, + 1538, 0, 5636, 5637, 5638, 5639, 5640, 5641, + 5642, 5643, 5644, 5645, 5646, 5647, 5648, 5649, + 5650, 5651, 5652, 5653, 5654, 5655, 5656, 5657, + 5658, 5659, 5660, 5661, 5662, 5663, 5664, 5665, + 5666, 5667, 5668, 5669, 5670, 5671, 5672, 5673, + 5674, 5675, 5676, 5677, 5678, 5679, 5680, 5681, + 5682, 5683, 5684, 5685, 5686, 5687, 5688, 5689, + 5690, 5691, 5692, 5693, 5694, 5695, 5696, 5697, + 5698, 5699, 5700, 5701, 5702, 5703, 5704, 5705, + 5706, 5707, 5708, 5709, 5710, 5711, 5712, 5713, + 5714, 5715, 5716, 5717, 5718, 5719, 5720, 5721, + 5722, 5723, 5724, 5725, 5726, 5727, 5728, 5729, + 5730, 5731, 5732, 5733, 5734, 5735, 5736, 5737, + 5738, 5739, 5740, 5741, 5742, 5743, 5744, 5745, + 5746, 5747, 5748, 5749, 5750, 5751, 5752, 5753, + 5754, 5755, 5756, 5757, 5758, 5759, 5760, 5761, + 5762, 5763, 5764, 5765, 5766, 5767, 5768, 5769, + 5770, 5771, 5772, 5773, 5774, 5775, 5776, 5777, + 5778, 5779, 5780, 5781, 5782, 5783, 5784, 5785, + 5786, 5787, 5788, 5789, 5790, 5791, 5792, 5793, + 5794, 5795, 5796, 5797, 5798, 5799, 5800, 5801, + 5802, 5803, 5804, 5805, 5806, 5807, 5808, 5809, + 5810, 5811, 5812, 5813, 5814, 5815, 5816, 5817, + 5818, 5819, 5820, 5821, 5822, 5823, 5824, 5825, + 0, 0, 0, 5826, 5827, 5828, 5829, 5830, + 5831, 0, 0, 5832, 5833, 5834, 5835, 5836, + 5837, 0, 0, 5838, 5839, 5840, 5841, 5842, + 5843, 0, 0, 5844, 5845, 5846, 0, 0, + 0, 5847, 5848, 5849, 5850, 5851, 5852, 5853, + 0, 5854, 5855, 5856, 5857, 5858, 5859, 5860, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 5861, 5861, 5861, 76, 76, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 0, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 0, 345, 345, 0, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 0, 0, 0, 0, + 0, 1119, 8, 1119, 0, 0, 0, 0, + 1258, 1258, 1258, 1258, 1258, 1258, 1258, 1258, + 1258, 1258, 1258, 1258, 1258, 1258, 1258, 1258, + 1258, 1258, 1258, 1258, 1258, 1258, 1258, 1258, + 1258, 1258, 1258, 1258, 1258, 1258, 1258, 1258, + 1258, 1258, 1258, 1258, 1258, 1258, 1258, 1258, + 1258, 1258, 1258, 1258, 1258, 0, 0, 0, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 5862, 5862, 5862, 5862, 5862, 5862, 5862, + 5862, 5862, 5862, 5862, 5862, 5862, 5862, 5862, + 5862, 5862, 5862, 5862, 5862, 5862, 5862, 5862, + 5862, 5862, 5862, 5862, 5862, 5862, 5862, 5862, + 5862, 5862, 5862, 5862, 5862, 5862, 5862, 5862, + 5862, 5862, 5862, 5862, 5862, 5862, 5862, 5862, + 5862, 5862, 5862, 5862, 5862, 5862, 1288, 1288, + 1288, 1288, 76, 76, 76, 76, 76, 76, + 76, 76, 76, 76, 76, 76, 76, 76, + 76, 76, 76, 1288, 1288, 76, 913, 913, + 0, 76, 76, 76, 76, 76, 76, 76, + 76, 76, 76, 76, 76, 76, 0, 0, + 0, 76, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 627, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 627, 5863, 5863, 5863, 5863, 5863, 5863, + 5863, 5863, 5863, 5863, 5863, 5863, 5863, 5863, + 5863, 5863, 5863, 5863, 5863, 5863, 5863, 5863, + 5863, 5863, 5863, 5863, 5863, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 1258, 1258, 1258, 1258, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 1536, 345, 345, 345, 345, 345, + 345, 345, 345, 1536, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 614, + 614, 614, 614, 614, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 0, + 1119, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 1119, 1536, 1536, 1536, 1536, 1536, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 5864, 5865, 5866, 5867, 5868, 5869, 5870, + 5871, 5872, 5873, 5874, 5875, 5876, 5877, 5878, + 5879, 5880, 5881, 5882, 5883, 5884, 5885, 5886, + 5887, 5888, 5889, 5890, 5891, 5892, 5893, 5894, + 5895, 5896, 5897, 5898, 5899, 5900, 5901, 5902, + 5903, 5904, 5905, 5906, 5907, 5908, 5909, 5910, + 5911, 5912, 5913, 5914, 5915, 5916, 5917, 5918, + 5919, 5920, 5921, 5922, 5923, 5924, 5925, 5926, + 5927, 5928, 5929, 5930, 5931, 5932, 5933, 5934, + 5935, 5936, 5937, 5938, 5939, 5940, 5941, 5942, + 5943, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 0, + 0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 0, 0, 0, 0, 0, + 0, 5944, 5945, 5946, 5947, 5948, 5949, 5950, + 5951, 5952, 5953, 5954, 5955, 5956, 5957, 5958, + 5959, 5960, 5961, 5962, 5963, 5964, 5965, 5966, + 5967, 5968, 5969, 5970, 5971, 5972, 5973, 5974, + 5975, 5976, 5977, 5978, 5979, 0, 0, 0, + 0, 5980, 5981, 5982, 5983, 5984, 5985, 5986, + 5987, 5988, 5989, 5990, 5991, 5992, 5993, 5994, + 5995, 5996, 5997, 5998, 5999, 6000, 6001, 6002, + 6003, 6004, 6005, 6006, 6007, 6008, 6009, 6010, + 6011, 6012, 6013, 6014, 6015, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1119, 6016, 6017, 6018, 6019, 6020, 6021, 6022, + 6023, 6024, 6025, 6026, 0, 6027, 6028, 6029, + 6030, 6031, 6032, 6033, 6034, 6035, 6036, 6037, + 6038, 6039, 6040, 6041, 0, 6042, 6043, 6044, + 6045, 6046, 6047, 6048, 0, 6049, 6050, 0, + 6051, 6052, 6053, 6054, 6055, 6056, 6057, 6058, + 6059, 6060, 6061, 0, 6062, 6063, 6064, 6065, + 6066, 6067, 6068, 6069, 6070, 6071, 6072, 6073, + 6074, 6075, 6076, 0, 6077, 6078, 6079, 6080, + 6081, 6082, 6083, 0, 6084, 6085, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 6086, 6087, 6088, 6089, 6090, 6091, 0, + 6092, 6093, 6094, 6095, 6096, 6097, 6098, 6099, + 6100, 6101, 6102, 6103, 6104, 6105, 6106, 6107, + 6108, 6109, 6110, 6111, 6112, 6113, 6114, 6115, + 6116, 6117, 6118, 6119, 6120, 6121, 6122, 6123, + 6124, 6125, 6126, 6127, 6128, 6129, 6130, 6131, + 6132, 6133, 0, 6134, 6135, 6136, 6137, 6138, + 6139, 6140, 6141, 6142, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1182, 1182, 1182, 1182, 1182, 1182, 0, + 0, 1182, 0, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 0, + 1182, 1182, 0, 0, 0, 1182, 0, 0, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 0, + 1179, 6143, 6143, 6143, 6143, 6143, 6143, 6143, + 6143, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 6144, 6144, 6143, 6143, 6143, 6143, 6143, 6143, + 6143, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, - 1182, 1182, 1182, 1182, 1182, 0, 0, 0, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 5587, 5587, 5587, 5587, 5587, 5587, 5587, - 5587, 5587, 5587, 5587, 5587, 5587, 5587, 5587, - 5587, 5587, 5587, 5587, 5587, 5587, 5587, 5587, - 5587, 5587, 5587, 5587, 5587, 5587, 5587, 5587, - 5587, 5587, 5587, 5587, 5587, 5587, 5587, 5587, - 5587, 5587, 5587, 5587, 5587, 5587, 5587, 5587, - 5587, 5587, 5587, 5587, 5587, 5587, 1211, 1211, - 1211, 1211, 77, 77, 77, 77, 77, 77, - 77, 77, 77, 77, 77, 77, 77, 77, - 77, 77, 77, 1211, 1211, 77, 841, 841, - 0, 77, 77, 77, 77, 77, 77, 77, - 77, 77, 77, 77, 77, 0, 0, 0, - 0, 77, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 556, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 556, 5588, 5588, 5588, 5588, 5588, 5588, - 5588, 5588, 5588, 5588, 5588, 5588, 5588, 5588, - 5588, 5588, 5588, 5588, 5588, 5588, 5588, 5588, - 5588, 5588, 5588, 5588, 5588, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 1182, 1182, 1182, 1182, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 1458, 341, 341, 341, 341, 341, - 341, 341, 341, 1458, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 543, - 543, 543, 543, 543, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 0, - 1047, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 1047, 1458, 1458, 1458, 1458, 1458, 0, + 6143, 6143, 6143, 6143, 6143, 6143, 6143, 6143, + 6143, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 5589, 5590, 5591, 5592, 5593, 5594, 5595, - 5596, 5597, 5598, 5599, 5600, 5601, 5602, 5603, - 5604, 5605, 5606, 5607, 5608, 5609, 5610, 5611, - 5612, 5613, 5614, 5615, 5616, 5617, 5618, 5619, - 5620, 5621, 5622, 5623, 5624, 5625, 5626, 5627, - 5628, 5629, 5630, 5631, 5632, 5633, 5634, 5635, - 5636, 5637, 5638, 5639, 5640, 5641, 5642, 5643, - 5644, 5645, 5646, 5647, 5648, 5649, 5650, 5651, - 5652, 5653, 5654, 5655, 5656, 5657, 5658, 5659, - 5660, 5661, 5662, 5663, 5664, 5665, 5666, 5667, - 5668, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 0, - 0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 0, 0, 0, 0, 0, - 0, 5669, 5670, 5671, 5672, 5673, 5674, 5675, - 5676, 5677, 5678, 5679, 5680, 5681, 5682, 5683, - 5684, 5685, 5686, 5687, 5688, 5689, 5690, 5691, - 5692, 5693, 5694, 5695, 5696, 5697, 5698, 5699, - 5700, 5701, 5702, 5703, 5704, 0, 0, 0, - 0, 5705, 5706, 5707, 5708, 5709, 5710, 5711, - 5712, 5713, 5714, 5715, 5716, 5717, 5718, 5719, - 5720, 5721, 5722, 5723, 5724, 5725, 5726, 5727, - 5728, 5729, 5730, 5731, 5732, 5733, 5734, 5735, - 5736, 5737, 5738, 5739, 5740, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 0, 0, 0, + 0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 0, 1182, 1182, 0, + 0, 0, 0, 0, 6143, 6143, 6143, 6143, + 6143, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 6143, + 6143, 6143, 6143, 6143, 6143, 0, 0, 0, + 8, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 0, 0, 0, 0, 0, + 1179, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1047, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 0, 0, 0, 0, 6143, 6143, 1182, + 1182, 6143, 6143, 6143, 6143, 6143, 6143, 6143, + 6143, 6143, 6143, 6143, 6143, 6143, 6143, 6143, + 6143, 0, 0, 6143, 6143, 6143, 6143, 6143, + 6143, 6143, 6143, 6143, 6143, 6143, 6143, 6143, + 6143, 6143, 6143, 6143, 6143, 6143, 6143, 6143, + 6143, 6143, 6143, 6143, 6143, 6143, 6143, 6143, + 6143, 6143, 6143, 6143, 6143, 6143, 6143, 6143, + 6143, 6143, 6143, 6143, 6143, 6143, 6143, 6143, + 6143, 1182, 1225, 1225, 1225, 0, 1225, 1225, + 0, 0, 0, 0, 0, 1225, 627, 1225, + 614, 1182, 1182, 1182, 1182, 0, 1182, 1182, + 1182, 0, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 0, + 0, 614, 640, 627, 0, 0, 0, 0, + 1299, 6143, 6143, 6143, 6143, 6143, 6143, 6143, + 6143, 6143, 0, 0, 0, 0, 0, 0, + 0, 1179, 1179, 1179, 1179, 1179, 1179, 1179, + 1179, 1179, 0, 0, 0, 0, 0, 0, + 0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 6143, 6143, + 1179, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 6143, 6143, + 6143, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 6144, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 614, 627, + 0, 0, 0, 0, 6143, 6143, 6143, 6143, + 6143, 1179, 1179, 1179, 1179, 1179, 1179, 1179, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 0, + 0, 0, 8, 8, 8, 8, 8, 8, + 8, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 0, + 0, 6143, 6143, 6143, 6143, 6143, 6143, 6143, + 6143, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 0, 0, 0, 0, + 0, 6143, 6143, 6143, 6143, 6143, 6143, 6143, + 6143, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 0, 0, 0, 0, 0, + 0, 0, 1179, 1179, 1179, 1179, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 6143, 6143, 6143, 6143, 6143, 6143, + 6143, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 6145, 6146, 6147, 6148, 6149, 6150, 6151, + 6152, 6153, 6154, 6155, 6156, 6157, 6158, 6159, + 6160, 6161, 6162, 6163, 6164, 6165, 6166, 6167, + 6168, 6169, 6170, 6171, 6172, 6173, 6174, 6175, + 6176, 6177, 6178, 6179, 6180, 6181, 6182, 6183, + 6184, 6185, 6186, 6187, 6188, 6189, 6190, 6191, + 6192, 6193, 6194, 6195, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 6196, 6197, 6198, 6199, 6200, 6201, 6202, + 6203, 6204, 6205, 6206, 6207, 6208, 6209, 6210, + 6211, 6212, 6213, 6214, 6215, 6216, 6217, 6218, + 6219, 6220, 6221, 6222, 6223, 6224, 6225, 6226, + 6227, 6228, 6229, 6230, 6231, 6232, 6233, 6234, + 6235, 6236, 6237, 6238, 6239, 6240, 6241, 6242, + 6243, 6244, 6245, 6246, 0, 0, 0, 0, + 0, 0, 0, 6143, 6143, 6143, 6143, 6143, + 6143, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 614, 614, 614, + 614, 0, 0, 0, 0, 0, 0, 0, + 0, 1209, 1209, 1209, 1209, 1209, 1209, 1209, + 1209, 1209, 1209, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -4538,47 +5064,12 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1108, 1108, 1108, 1108, 1108, 1108, 0, - 0, 1108, 0, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 0, - 1108, 1108, 0, 0, 0, 1108, 0, 0, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 0, - 1105, 5741, 5741, 5741, 5741, 5741, 5741, 5741, - 5741, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 5742, 5742, 5741, 5741, 5741, 5741, 5741, 5741, - 5741, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 0, 0, 0, 0, 0, 0, 0, 0, - 5741, 5741, 5741, 5741, 5741, 5741, 5741, 5741, - 5741, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 0, 1108, 1108, 0, - 0, 0, 0, 0, 5741, 5741, 5741, 5741, - 5741, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 5741, - 5741, 5741, 5741, 5741, 5741, 0, 0, 0, - 9, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 0, 0, 0, 0, 0, - 1105, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -4586,77 +5077,11 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 0, 0, 0, 0, 5741, 5741, 1108, - 1108, 5741, 5741, 5741, 5741, 5741, 5741, 5741, - 5741, 5741, 5741, 5741, 5741, 5741, 5741, 5741, - 5741, 0, 0, 5741, 5741, 5741, 5741, 5741, - 5741, 5741, 5741, 5741, 5741, 5741, 5741, 5741, - 5741, 5741, 5741, 5741, 5741, 5741, 5741, 5741, - 5741, 5741, 5741, 5741, 5741, 5741, 5741, 5741, - 5741, 5741, 5741, 5741, 5741, 5741, 5741, 5741, - 5741, 5741, 5741, 5741, 5741, 5741, 5741, 5741, - 5741, 1108, 1151, 1151, 1151, 0, 1151, 1151, - 0, 0, 0, 0, 0, 1151, 556, 1151, - 543, 1108, 1108, 1108, 1108, 0, 1108, 1108, - 1108, 0, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 0, - 0, 543, 569, 556, 0, 0, 0, 0, - 1163, 5741, 5741, 5741, 5741, 5741, 5741, 5741, - 5741, 5741, 0, 0, 0, 0, 0, 0, - 0, 1105, 1105, 1105, 1105, 1105, 1105, 1105, - 1105, 1105, 0, 0, 0, 0, 0, 0, - 0, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 5741, 5741, - 1105, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 5741, 5741, - 5741, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 5742, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 543, 556, - 0, 0, 0, 0, 5741, 5741, 5741, 5741, - 5741, 1105, 1105, 1105, 1105, 1105, 1105, 1105, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 0, - 0, 0, 9, 9, 9, 9, 9, 9, - 9, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 0, - 0, 5741, 5741, 5741, 5741, 5741, 5741, 5741, - 5741, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 0, 0, 0, 0, - 0, 5741, 5741, 5741, 5741, 5741, 5741, 5741, - 5741, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 0, 0, 0, 0, 0, - 0, 0, 1105, 1105, 1105, 1105, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 5741, 5741, 5741, 5741, 5741, 5741, - 5741, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -4665,56 +5090,131 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 6247, 6247, 6247, 6247, 6247, 6247, 6247, + 6247, 6247, 6247, 6247, 6247, 6247, 6247, 6247, + 6247, 6247, 6247, 6247, 6247, 6247, 6247, 6247, + 6247, 6247, 6247, 6247, 6247, 6247, 6247, 6247, + 0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 0, 614, 614, 1177, 0, + 0, 1182, 1182, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 5743, 5744, 5745, 5746, 5747, 5748, 5749, - 5750, 5751, 5752, 5753, 5754, 5755, 5756, 5757, - 5758, 5759, 5760, 5761, 5762, 5763, 5764, 5765, - 5766, 5767, 5768, 5769, 5770, 5771, 5772, 5773, - 5774, 5775, 5776, 5777, 5778, 5779, 5780, 5781, - 5782, 5783, 5784, 5785, 5786, 5787, 5788, 5789, - 5790, 5791, 5792, 5793, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 5794, 5795, 5796, 5797, 5798, 5799, 5800, - 5801, 5802, 5803, 5804, 5805, 5806, 5807, 5808, - 5809, 5810, 5811, 5812, 5813, 5814, 5815, 5816, - 5817, 5818, 5819, 5820, 5821, 5822, 5823, 5824, - 5825, 5826, 5827, 5828, 5829, 5830, 5831, 5832, - 5833, 5834, 5835, 5836, 5837, 5838, 5839, 5840, - 5841, 5842, 5843, 5844, 0, 0, 0, 0, - 0, 0, 0, 5741, 5741, 5741, 5741, 5741, - 5741, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 543, 543, 543, - 543, 0, 0, 0, 0, 0, 0, 0, - 0, 1135, 1135, 1135, 1135, 1135, 1135, 1135, - 1135, 1135, 1135, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 627, 627, + 627, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 6143, 6143, + 6143, 6143, 6143, 6143, 6143, 6143, 6143, 6143, + 1182, 0, 0, 0, 0, 0, 0, 0, + 0, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 1191, + 1191, 1191, 1191, 1191, 1191, 1191, 1191, 627, + 627, 614, 614, 614, 627, 614, 627, 627, + 627, 627, 6248, 6248, 6248, 6248, 1186, 1186, + 1186, 1186, 1186, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 614, 627, 614, 627, 1179, + 1179, 1179, 1179, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 6143, 6143, + 6143, 6143, 6143, 6143, 6143, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1230, 1225, 1230, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1261, + 1119, 1119, 1119, 1119, 1119, 1119, 1119, 0, + 0, 0, 0, 1288, 1288, 1288, 1288, 1288, + 1288, 1288, 1288, 1288, 1288, 1288, 1288, 1288, + 1288, 1288, 1288, 1288, 1288, 1288, 1288, 1248, + 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1299, 345, 345, 1225, 1225, 345, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1299, 1225, 1225, 1230, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 6249, 6250, 6251, 6252, 345, 345, + 345, 345, 345, 345, 345, 345, 6253, 345, + 345, 345, 345, 345, 6254, 345, 345, 345, + 345, 1230, 1230, 1230, 1225, 1225, 1225, 1225, + 1230, 1230, 1261, 6255, 1119, 1119, 6256, 1119, + 1119, 1119, 1119, 1225, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 6256, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 0, 0, 0, 0, 0, 0, + 0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 0, 0, 0, 0, 0, + 0, 614, 614, 614, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 6257, 1225, 1225, 1225, 1225, 1230, 1225, 6258, + 6259, 1225, 6260, 6261, 1299, 1299, 0, 1248, + 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1119, 1119, 1119, 1119, 345, 1230, 1230, + 345, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 1249, 1119, 1119, 345, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1225, 1225, 1230, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 1230, 1230, 1230, 1225, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 1230, 1537, 345, 1306, 1306, 345, 1119, 1119, + 1119, 1119, 1225, 1249, 1225, 1225, 1119, 1230, + 1225, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 345, 1119, 345, 1119, 1119, + 1119, 0, 1258, 1258, 1258, 1258, 1258, 1258, + 1258, 1258, 1258, 1258, 1258, 1258, 1258, 1258, + 1258, 1258, 1258, 1258, 1258, 1258, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 0, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 1230, 1230, 1230, + 1225, 1225, 1225, 1230, 1230, 1225, 1537, 1249, + 1225, 1119, 1119, 1119, 1119, 1119, 1119, 1225, + 345, 345, 1225, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -4722,6 +5222,37 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 0, 345, 0, 345, 345, 345, 345, 0, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 0, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 1119, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 1225, 1230, 1230, 1230, 1225, 1225, 1225, 1225, + 1225, 1225, 1249, 1299, 0, 0, 0, 0, + 0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 0, 0, 0, 0, 0, + 0, 1225, 1225, 1230, 1230, 0, 345, 345, + 345, 345, 345, 345, 345, 345, 0, 0, + 345, 345, 0, 0, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 0, 345, 345, 345, 345, 345, + 345, 345, 0, 345, 345, 0, 345, 345, + 345, 345, 345, 0, 1249, 1249, 345, 6262, + 1230, 1225, 1230, 1230, 1230, 1230, 0, 0, + 6263, 1230, 0, 0, 6264, 6265, 1537, 0, + 0, 345, 0, 0, 0, 0, 0, 0, + 6266, 0, 0, 0, 0, 0, 345, 345, + 345, 345, 345, 1230, 1230, 0, 0, 614, + 614, 614, 614, 614, 614, 614, 0, 0, + 0, 614, 614, 614, 614, 614, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -4739,13 +5270,34 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 1230, 1230, + 1230, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 1230, 1230, 1261, 1225, 1225, 1230, 1249, + 345, 345, 345, 345, 1119, 1119, 1119, 1119, + 1119, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 1119, 1119, 0, 1119, 614, + 345, 345, 345, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 5845, 5845, 5845, 5845, 5845, 5845, 5845, - 5845, 5845, 5845, 5845, 5845, 5845, 5845, 5845, - 5845, 5845, 5845, 5845, 5845, 5845, 5845, 5845, - 5845, 5845, 5845, 5845, 5845, 5845, 5845, 5845, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 6267, 1230, 1230, 1225, 1225, 1225, 1225, + 1225, 1225, 6268, 6269, 6270, 6271, 6272, 6273, + 1225, 1225, 1230, 1261, 1249, 345, 345, 1119, + 345, 0, 0, 0, 0, 0, 0, 0, + 0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -4762,110 +5314,69 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 5741, 5741, - 5741, 5741, 5741, 5741, 5741, 5741, 5741, 5741, - 1108, 0, 0, 0, 0, 0, 0, 0, - 0, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, - 1117, 1117, 1117, 1117, 1117, 1117, 1117, 556, - 556, 543, 543, 543, 556, 543, 556, 556, - 556, 556, 5846, 5846, 5846, 5846, 1112, 1112, - 1112, 1112, 1112, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 6274, 1230, 1230, 1225, 1225, 1225, 1225, 0, + 0, 6275, 6276, 6277, 6278, 1225, 1225, 1230, + 1261, 1249, 1119, 1119, 1119, 1119, 1119, 1119, + 1119, 1119, 1119, 1119, 1119, 1119, 1119, 1119, + 1119, 1119, 1119, 1119, 1119, 1119, 1119, 1119, + 1119, 345, 345, 345, 345, 1225, 1225, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 1230, 1230, 1230, 1225, 1225, 1225, 1225, + 1225, 1225, 1225, 1225, 1230, 1230, 1225, 1230, + 1261, 1225, 1119, 1119, 1119, 345, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 0, 0, 0, 0, 0, + 0, 8, 8, 8, 8, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 1225, 1230, 1225, 1230, + 1230, 1225, 1225, 1225, 1225, 1225, 1225, 1537, + 1249, 345, 1119, 0, 0, 0, 0, 0, + 0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1155, 1151, 1155, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 1151, 1151, 1151, 1151, 1151, 1151, 1151, - 1151, 1151, 1151, 1151, 1151, 1151, 1151, 1163, - 1047, 1047, 1047, 1047, 1047, 1047, 1047, 0, - 0, 0, 0, 1211, 1211, 1211, 1211, 1211, - 1211, 1211, 1211, 1211, 1211, 1211, 1211, 1211, - 1211, 1211, 1211, 1211, 1211, 1211, 1211, 1172, - 1172, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 0, 0, 1225, 1225, + 1225, 1350, 1350, 1225, 1225, 1225, 1225, 1230, + 1225, 1225, 1225, 1225, 1299, 0, 0, 0, + 0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 1258, 1258, 1119, 1119, 1119, + 913, 345, 345, 345, 345, 345, 345, 345, 0, 0, 0, 0, 0, 0, 0, 0, - 1163, 1151, 1151, 1155, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 5847, 5848, 5849, 5850, 341, 341, - 341, 341, 341, 341, 341, 341, 5851, 341, - 341, 341, 341, 341, 5852, 341, 341, 341, - 341, 1155, 1155, 1155, 1151, 1151, 1151, 1151, - 1155, 1155, 1163, 5853, 1047, 1047, 5854, 1047, - 1047, 1047, 1047, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 5854, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 0, 0, 0, 0, 0, 0, - 0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 0, 0, 0, 0, 0, - 0, 543, 543, 543, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 5855, 1151, 1151, 1151, 1151, 1155, 1151, 5856, - 5857, 1151, 5858, 5859, 1163, 1163, 0, 1172, - 1172, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1047, 1047, 1047, 1047, 341, 1155, 1155, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 1173, 1047, 1047, 341, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1151, 1151, 1155, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 1155, 1155, 1155, 1151, - 1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, - 1155, 1483, 341, 1228, 1228, 341, 1047, 1047, - 1047, 1047, 1151, 1173, 1151, 1151, 1047, 0, - 0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 341, 1047, 341, 1047, 1047, - 1047, 0, 1182, 1182, 1182, 1182, 1182, 1182, - 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, - 1182, 1182, 1182, 1182, 1182, 1182, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 0, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 1155, 1155, 1155, - 1151, 1151, 1151, 1155, 1155, 1151, 1483, 1173, - 1151, 1047, 1047, 1047, 1047, 1047, 1047, 1151, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -4874,37 +5385,6 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 0, 341, 0, 341, 341, 341, 341, 0, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 0, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 1047, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 1151, 1155, 1155, 1155, 1151, 1151, 1151, 1151, - 1151, 1151, 1173, 1163, 0, 0, 0, 0, - 0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 0, 0, 0, 0, 0, - 0, 1151, 1151, 1155, 1155, 0, 341, 341, - 341, 341, 341, 341, 341, 341, 0, 0, - 341, 341, 0, 0, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 0, 341, 341, 341, 341, 341, - 341, 341, 0, 341, 341, 0, 341, 341, - 341, 341, 341, 0, 1173, 1173, 341, 5860, - 1155, 1151, 1155, 1155, 1155, 1155, 0, 0, - 5861, 1155, 0, 0, 5862, 5863, 1483, 0, - 0, 341, 0, 0, 0, 0, 0, 0, - 5864, 0, 0, 0, 0, 0, 341, 341, - 341, 341, 341, 1155, 1155, 0, 0, 543, - 543, 543, 543, 543, 543, 543, 0, 0, - 0, 543, 543, 543, 543, 543, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -4918,45 +5398,50 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 1230, 1230, 1230, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 1230, 1261, 1249, 1119, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 1155, 1155, - 1155, 1151, 1151, 1151, 1151, 1151, 1151, 1151, - 1151, 1155, 1155, 1163, 1151, 1151, 1155, 1173, - 341, 341, 341, 341, 1047, 1047, 1047, 1047, - 1047, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 0, 1047, 0, 1047, 543, - 341, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 5865, 1155, 1155, 1151, 1151, 1151, 1151, - 1151, 1151, 5866, 5867, 5868, 5869, 5870, 5871, - 1151, 1151, 1155, 1163, 1173, 341, 341, 1047, - 341, 0, 0, 0, 0, 0, 0, 0, - 0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 6279, 6280, 6281, 6282, 6283, 6284, 6285, + 6286, 6287, 6288, 6289, 6290, 6291, 6292, 6293, + 6294, 6295, 6296, 6297, 6298, 6299, 6300, 6301, + 6302, 6303, 6304, 6305, 6306, 6307, 6308, 6309, + 6310, 6311, 6312, 6313, 6314, 6315, 6316, 6317, + 6318, 6319, 6320, 6321, 6322, 6323, 6324, 6325, + 6326, 6327, 6328, 6329, 6330, 6331, 6332, 6333, + 6334, 6335, 6336, 6337, 6338, 6339, 6340, 6341, + 6342, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 1258, 1258, 1258, 1258, 1258, + 1258, 1258, 1258, 1258, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 345, 345, 345, 345, 345, 345, 345, 345, + 0, 0, 345, 0, 0, 345, 345, 345, + 345, 345, 345, 345, 345, 0, 345, 345, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 6343, 1230, 1230, 1230, 1230, 6344, 0, + 1230, 6345, 0, 0, 1225, 1225, 1537, 1299, + 1306, 1230, 1306, 1230, 1249, 1119, 1119, 1119, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -4965,68 +5450,66 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 0, 0, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 1230, 1230, 1230, 1225, 1225, 1225, + 1225, 0, 0, 1225, 1225, 1230, 1230, 1230, + 1230, 1261, 345, 1119, 345, 1230, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 1225, 1225, 1225, 1225, 1225, 1225, + 6346, 6346, 1225, 1225, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 1225, 1299, 1225, 1225, + 1225, 1225, 1230, 1306, 1225, 1225, 1225, 1225, + 1119, 1119, 1119, 1119, 1119, 1119, 1119, 1119, + 1299, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 1225, 1225, 1225, 1225, 1225, 1225, + 1230, 1230, 1225, 1225, 1225, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 1306, 1306, 1306, + 1306, 1306, 1306, 1225, 1225, 1225, 1225, 1225, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 1230, 1225, 1299, 1119, 1119, 1119, 345, 1119, + 1119, 1119, 1119, 1119, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 0, 0, 0, 0, 0, 0, + 0, 1119, 1119, 1119, 1119, 1119, 1119, 1119, + 1119, 1119, 1119, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 5872, 1155, 1155, 1151, 1151, 1151, 1151, 0, - 0, 5873, 5874, 5875, 5876, 1151, 1151, 1155, - 1163, 1173, 1047, 1047, 1047, 1047, 1047, 1047, - 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, - 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, - 1047, 341, 341, 341, 341, 1151, 1151, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 1155, 1155, 1155, 1151, 1151, 1151, 1151, - 1151, 1151, 1151, 1151, 1155, 1155, 1151, 1155, - 1163, 1151, 1047, 1047, 1047, 341, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 0, 0, 0, 0, 0, - 0, 9, 9, 9, 9, 9, 9, 9, - 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 1151, 1155, 1151, 1155, - 1155, 1151, 1151, 1151, 1151, 1151, 1151, 1483, - 1173, 341, 0, 0, 0, 0, 0, 0, - 0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 0, 0, 1151, 1151, - 1151, 1155, 1155, 1151, 1151, 1151, 1151, 1155, - 1151, 1151, 1151, 1151, 1163, 0, 0, 0, - 0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 1182, 1182, 1047, 1047, 1047, - 841, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5043,24 +5526,60 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 0, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 1230, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 0, 1225, 1225, 1225, 1225, 1225, 1225, 1230, + 6347, 345, 1119, 1119, 1119, 1119, 1119, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 1258, 1258, 1258, 1258, 1258, + 1258, 1258, 1258, 1258, 1258, 1258, 1258, 1258, + 1258, 1258, 1258, 1258, 1258, 1258, 0, 0, + 0, 1119, 1119, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 0, 0, 1225, 1225, 1225, 1225, 1225, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 0, 1230, 1225, 1225, 1225, 1225, 1225, + 1225, 1225, 1230, 1225, 1225, 1230, 1225, 1225, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 1155, 1155, 1155, - 1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, - 1151, 1155, 1163, 1173, 1047, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 0, 345, 345, 0, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 1225, 1225, 1225, 1225, 1225, 1225, + 0, 0, 0, 1225, 0, 1225, 1225, 0, + 1225, 1225, 1225, 1249, 1225, 1299, 1299, 1306, + 1225, 0, 0, 0, 0, 0, 0, 0, + 0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 0, + 345, 345, 0, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 1230, 1230, 1230, 1230, 1230, + 0, 1225, 1225, 0, 1230, 1230, 1225, 1230, + 1299, 345, 0, 0, 0, 0, 0, 0, + 0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5070,19 +5589,7 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 5877, 5878, 5879, 5880, 5881, 5882, 5883, - 5884, 5885, 5886, 5887, 5888, 5889, 5890, 5891, - 5892, 5893, 5894, 5895, 5896, 5897, 5898, 5899, - 5900, 5901, 5902, 5903, 5904, 5905, 5906, 5907, - 5908, 5909, 5910, 5911, 5912, 5913, 5914, 5915, - 5916, 5917, 5918, 5919, 5920, 5921, 5922, 5923, - 5924, 5925, 5926, 5927, 5928, 5929, 5930, 5931, - 5932, 5933, 5934, 5935, 5936, 5937, 5938, 5939, - 5940, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 1182, 1182, 1182, 1182, 1182, - 1182, 1182, 1182, 1182, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 341, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5102,53 +5609,31 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 0, 0, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 1155, 1155, 1155, 1151, 1151, 1151, - 1151, 0, 0, 1151, 1151, 1155, 1155, 1155, - 1155, 1163, 341, 1047, 341, 1155, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 1151, 1151, 1151, 1151, 1151, 1151, - 5941, 5941, 1151, 1151, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 1151, 1163, 1151, 1151, - 1151, 1151, 1155, 1228, 1151, 1151, 1151, 1151, - 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, - 1163, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 1151, 1151, 1151, 1151, 1151, 1151, - 1155, 1155, 1151, 1151, 1151, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 1228, 1228, 1228, - 1228, 1228, 1228, 1151, 1151, 1151, 1151, 1151, - 1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, - 1155, 1151, 1163, 1047, 1047, 1047, 341, 1047, - 1047, 1047, 1047, 1047, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 1225, 1225, 1230, 1230, + 1119, 1119, 0, 0, 0, 0, 0, 0, + 0, 1225, 1225, 1306, 1230, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 0, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 1230, 1230, 1225, + 1225, 1225, 1225, 1225, 0, 0, 0, 1230, + 1230, 1225, 1537, 1299, 1119, 1119, 1119, 1119, + 1119, 1119, 1119, 1119, 1119, 1119, 1119, 1119, + 1119, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5159,8 +5644,36 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1258, 1258, 1258, 1258, 1258, 1258, 1258, + 1258, 1258, 1258, 1258, 1258, 1258, 1258, 1258, + 1258, 1258, 1258, 1258, 1258, 1258, 76, 76, + 76, 76, 76, 76, 76, 76, 10, 10, + 10, 10, 76, 76, 76, 76, 76, 76, + 76, 76, 76, 76, 76, 76, 76, 76, + 76, 76, 76, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1119, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5173,34 +5686,52 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1536, 1536, 1536, 1536, 1536, 1536, 1536, + 1536, 1536, 1536, 1536, 1536, 1536, 1536, 1536, + 1536, 1536, 1536, 1536, 1536, 1536, 1536, 1536, + 1536, 1536, 1536, 1536, 1536, 1536, 1536, 1536, + 1536, 1536, 1536, 1536, 1536, 1536, 1536, 1536, + 1536, 1536, 1536, 1536, 1536, 1536, 1536, 1536, + 1536, 1536, 1536, 1536, 1536, 1536, 1536, 1536, + 1536, 1536, 1536, 1536, 1536, 1536, 1536, 1536, + 1536, 1536, 1536, 1536, 1536, 1536, 1536, 1536, + 1536, 1536, 1536, 1536, 1536, 1536, 1536, 1536, + 1536, 1536, 1536, 1536, 1536, 1536, 1536, 1536, + 1536, 1536, 1536, 1536, 1536, 1536, 1536, 1536, + 1536, 1536, 1536, 1536, 1536, 1536, 1536, 1536, + 1536, 1536, 1536, 1536, 1536, 1536, 1536, 1536, + 0, 1119, 1119, 1119, 1119, 1119, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 0, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 1155, 1151, 1151, 1151, 1151, 1151, 1151, 1151, - 0, 1151, 1151, 1151, 1151, 1151, 1151, 1155, - 5942, 341, 1047, 1047, 1047, 1047, 1047, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 1182, 1182, 1182, 1182, 1182, - 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, - 1182, 1182, 1182, 1182, 1182, 1182, 0, 0, - 0, 1047, 1047, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 0, 0, 1151, 1151, 1151, 1151, 1151, - 1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, - 1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, - 1151, 0, 1155, 1151, 1151, 1151, 1151, 1151, - 1151, 1151, 1155, 1151, 1151, 1155, 1151, 1151, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5210,28 +5741,6 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 0, 341, 341, 0, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 1151, 1151, 1151, 1151, 1151, 1151, - 0, 0, 0, 1151, 0, 1151, 1151, 0, - 1151, 1151, 1151, 1173, 1151, 1163, 1163, 1228, - 1151, 0, 0, 0, 0, 0, 0, 0, - 0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 0, - 341, 341, 0, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 1155, 1155, 1155, 1155, 1155, - 0, 1151, 1151, 0, 1155, 1155, 1151, 1155, - 1163, 341, 0, 0, 0, 0, 0, 0, - 0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5270,10 +5779,6 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 1151, 1151, 1155, 1155, - 1047, 1047, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5295,37 +5800,34 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 1119, 1119, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 6348, 6348, 6348, 6348, 6348, 6348, 6348, + 6348, 6348, 6348, 6348, 6348, 6348, 6348, 6348, + 6348, 1225, 345, 345, 345, 345, 345, 345, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, - 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, - 1182, 1182, 1182, 1182, 1182, 1182, 77, 77, - 77, 77, 77, 77, 77, 77, 11, 11, - 11, 11, 77, 77, 77, 77, 77, 77, - 77, 77, 77, 77, 77, 77, 77, 77, - 77, 77, 77, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1047, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5338,52 +5840,21 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1458, 1458, 1458, 1458, 1458, 1458, 1458, - 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, - 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, - 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, - 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, - 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, - 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, - 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, - 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, - 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, - 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, - 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, - 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, - 1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, - 0, 1047, 1047, 1047, 1047, 1047, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5402,21 +5873,62 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 0, 5943, 5943, 5943, 5943, 5943, 5943, 5943, - 5943, 5943, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 0, 0, 0, 0, 1119, + 1119, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 0, + 0, 640, 640, 640, 640, 640, 1119, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 614, 614, 614, 614, 614, 614, 614, + 1119, 1119, 1119, 1119, 1119, 913, 913, 913, + 913, 595, 595, 595, 595, 1119, 913, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 0, 1258, 1258, 1258, 1258, + 1258, 1258, 1258, 0, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 0, 0, 0, 0, 0, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5434,19 +5946,22 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 6349, 6350, 6351, 6352, 6353, 6354, 6355, + 6356, 6357, 6358, 6359, 6360, 6361, 6362, 6363, + 6364, 6365, 6366, 6367, 6368, 6369, 6370, 6371, + 6372, 6373, 6374, 6375, 6376, 6377, 6378, 6379, + 6380, 6381, 6382, 6383, 6384, 6385, 6386, 6387, + 6388, 6389, 6390, 6391, 6392, 6393, 6394, 6395, + 6396, 6397, 6398, 6399, 6400, 6401, 6402, 6403, + 6404, 6405, 6406, 6407, 6408, 6409, 6410, 6411, + 6412, 1258, 1258, 1258, 1258, 1258, 1258, 1258, + 1258, 1258, 1258, 1258, 1258, 1258, 1258, 1258, + 1258, 1258, 1258, 1258, 1258, 1258, 1258, 1258, + 1119, 1119, 1119, 1119, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5459,6 +5974,27 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 0, 0, 0, 0, + 1225, 345, 1230, 1230, 1230, 1230, 1230, 1230, + 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, + 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, + 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, + 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, + 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, + 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, + 1230, 0, 0, 0, 0, 0, 0, 0, + 1225, 1225, 1225, 1225, 595, 595, 595, 595, + 595, 595, 595, 595, 595, 595, 595, 595, + 595, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5466,57 +6002,82 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 0, 0, 0, 0, 1047, - 1047, 0, 0, 0, 0, 0, 0, 0, + 0, 3226, 3226, 3225, 3226, 1225, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 6413, 6413, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 0, 0, 0, 0, 0, 0, 0, + 0, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 0, - 0, 569, 569, 569, 569, 569, 1047, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 543, 543, 543, 543, 543, 543, 543, - 1047, 1047, 1047, 1047, 1047, 841, 841, 841, - 841, 525, 525, 525, 525, 1047, 841, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 0, 1182, 1182, 1182, 1182, - 1182, 1182, 1182, 0, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 0, 0, 0, 0, 0, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5538,295 +6099,8 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 5944, 5945, 5946, 5947, 5948, 5949, 5950, - 5951, 5952, 5953, 5954, 5955, 5956, 5957, 5958, - 5959, 5960, 5961, 5962, 5963, 5964, 5965, 5966, - 5967, 5968, 5969, 5970, 5971, 5972, 5973, 5974, - 5975, 5976, 5977, 5978, 5979, 5980, 5981, 5982, - 5983, 5984, 5985, 5986, 5987, 5988, 5989, 5990, - 5991, 5992, 5993, 5994, 5995, 5996, 5997, 5998, - 5999, 6000, 6001, 6002, 6003, 6004, 6005, 6006, - 6007, 1182, 1182, 1182, 1182, 1182, 1182, 1182, - 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, - 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, - 1047, 1047, 1047, 1047, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 0, 0, 0, 0, - 1151, 341, 1155, 1155, 1155, 1155, 1155, 1155, - 1155, 1155, 1155, 1155, 1155, 1155, 1155, 1155, - 1155, 1155, 1155, 1155, 1155, 1155, 1155, 1155, - 1155, 1155, 1155, 1155, 1155, 1155, 1155, 1155, - 1155, 1155, 1155, 1155, 1155, 1155, 1155, 1155, - 1155, 1155, 1155, 1155, 1155, 1155, 1155, 1155, - 1155, 1155, 1155, 1155, 1155, 1155, 1155, 1155, - 1155, 0, 0, 0, 0, 0, 0, 0, - 1151, 1151, 1151, 1151, 525, 525, 525, 525, - 525, 525, 525, 525, 525, 525, 525, 525, - 525, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 3034, 3034, 3033, 3034, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 0, 0, 0, 0, 0, 0, 0, - 0, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 3035, 3035, 3035, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 3035, 3035, 3035, - 3035, 0, 0, 0, 0, 0, 0, 0, - 0, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 0, 0, 841, 1151, 569, - 1047, 1459, 1459, 1459, 1459, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 0, 0, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 6008, 6009, 841, 841, 841, 841, 841, 6010, - 6011, 6012, 6013, 6014, 6015, 6016, 6017, 6018, - 569, 569, 569, 841, 841, 841, 6019, 6020, - 6021, 6022, 6023, 6024, 1459, 1459, 1459, 1459, - 1459, 1459, 1459, 1459, 556, 556, 556, 556, - 556, 556, 556, 556, 841, 841, 543, 543, - 543, 543, 543, 556, 556, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 543, 543, 543, 543, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 6025, 6026, 6027, 6028, 6029, 6030, - 6031, 6032, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 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, 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, 543, 543, 543, 77, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5846,26 +6120,7 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, - 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, - 1182, 1182, 1182, 1182, 1182, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 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, 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, 77, 77, 77, 77, 77, 77, 77, - 77, 77, 77, 77, 77, 77, 77, 77, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, - 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, - 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, - 1182, 1182, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5877,164 +6132,209 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3226, 3226, 3226, 3226, 0, 3226, 3226, + 3226, 3226, 3226, 3226, 3226, 0, 3226, 3226, + 0, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3227, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3227, 3227, 3227, 0, 0, 3227, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 6033, 2233, 2208, 2251, 2235, 2236, 6034, - 2215, 2218, 6035, 6036, 2219, 2238, 2221, 6037, - 2223, 2224, 2225, 6038, 6039, 6040, 6041, 6042, - 6043, 6044, 2229, 6045, 6046, 6047, 2252, 2234, - 6048, 2214, 2216, 2253, 2254, 6049, 2220, 6050, - 6051, 2239, 6052, 6053, 6054, 6055, 6056, 6057, - 6058, 6059, 6060, 6061, 6062, 6033, 2233, 2208, - 2251, 2235, 2236, 6034, 2215, 2218, 6035, 6036, - 2219, 2238, 2221, 6037, 2223, 2224, 2225, 6038, - 6039, 6040, 6041, 6042, 6043, 6044, 2229, 6045, - 6046, 6047, 2252, 2234, 6048, 2214, 0, 2253, - 2254, 6049, 2220, 6050, 6051, 2239, 6052, 6053, - 6054, 6055, 6056, 6057, 6058, 6059, 6060, 6061, - 6062, 6033, 2233, 2208, 2251, 2235, 2236, 6034, - 2215, 2218, 6035, 6036, 2219, 2238, 2221, 6037, - 2223, 2224, 2225, 6038, 6039, 6040, 6041, 6042, - 6043, 6044, 2229, 6045, 6046, 6047, 2252, 2234, - 6048, 2214, 2216, 2253, 2254, 6049, 2220, 6050, - 6051, 2239, 6052, 6053, 6054, 6055, 6056, 6057, - 6058, 6059, 6060, 6061, 6062, 6033, 0, 2208, - 2251, 0, 0, 6034, 0, 0, 6035, 6036, - 0, 0, 2221, 6037, 2223, 2224, 0, 6038, - 6039, 6040, 6041, 6042, 6043, 6044, 2229, 6045, - 6046, 6047, 2252, 0, 6048, 0, 2216, 2253, - 2254, 6049, 2220, 6050, 6051, 0, 6052, 6053, - 6054, 6055, 6056, 6057, 6058, 6059, 6060, 6061, - 6062, 6033, 2233, 2208, 2251, 2235, 2236, 6034, - 2215, 2218, 6035, 6036, 2219, 2238, 2221, 6037, - 2223, 2224, 2225, 6038, 6039, 6040, 6041, 6042, - 6043, 6044, 2229, 6045, 6046, 6047, 2252, 2234, - 6048, 2214, 2216, 2253, 2254, 6049, 2220, 6050, - 6051, 2239, 6052, 6053, 6054, 6055, 6056, 6057, - 6058, 6059, 6060, 6061, 6062, 6033, 2233, 0, - 2251, 2235, 2236, 6034, 0, 0, 6035, 6036, - 2219, 2238, 2221, 6037, 2223, 2224, 0, 6038, - 6039, 6040, 6041, 6042, 6043, 6044, 0, 6045, - 6046, 6047, 2252, 2234, 6048, 2214, 2216, 2253, - 2254, 6049, 2220, 6050, 6051, 2239, 6052, 6053, - 6054, 6055, 6056, 6057, 6058, 6059, 6060, 6061, - 6062, 6033, 2233, 0, 2251, 2235, 2236, 6034, - 0, 2218, 6035, 6036, 2219, 2238, 0, 6037, - 0, 0, 0, 6038, 6039, 6040, 6041, 6042, - 6043, 6044, 0, 6045, 6046, 6047, 2252, 2234, - 6048, 2214, 2216, 2253, 2254, 6049, 2220, 6050, - 6051, 2239, 6052, 6053, 6054, 6055, 6056, 6057, - 6058, 6059, 6060, 6061, 6062, 6033, 2233, 2208, - 2251, 2235, 2236, 6034, 2215, 2218, 6035, 6036, - 2219, 2238, 2221, 6037, 2223, 2224, 2225, 6038, - 6039, 6040, 6041, 6042, 6043, 6044, 2229, 6045, - 6046, 6047, 2252, 2234, 6048, 2214, 2216, 2253, - 2254, 6049, 2220, 6050, 6051, 2239, 6052, 6053, - 6054, 6055, 6056, 6057, 6058, 6059, 6060, 6061, - 6062, 6033, 2233, 2208, 2251, 2235, 2236, 6034, - 2215, 2218, 6035, 6036, 2219, 2238, 2221, 6037, - 2223, 2224, 2225, 6038, 6039, 6040, 6041, 6042, - 6043, 6044, 2229, 6045, 6046, 6047, 2252, 2234, - 6048, 2214, 2216, 2253, 2254, 6049, 2220, 6050, - 6051, 2239, 6052, 6053, 6054, 6055, 6056, 6057, - 6058, 6059, 6060, 6061, 6062, 6033, 2233, 2208, - 2251, 2235, 2236, 6034, 2215, 2218, 6035, 6036, - 2219, 2238, 2221, 6037, 2223, 2224, 2225, 6038, - 6039, 6040, 6041, 6042, 6043, 6044, 2229, 6045, - 6046, 6047, 2252, 2234, 6048, 2214, 2216, 2253, - 2254, 6049, 2220, 6050, 6051, 2239, 6052, 6053, - 6054, 6055, 6056, 6057, 6058, 6059, 6060, 6061, - 6062, 6033, 2233, 2208, 2251, 2235, 2236, 6034, - 2215, 2218, 6035, 6036, 2219, 2238, 2221, 6037, - 2223, 2224, 2225, 6038, 6039, 6040, 6041, 6042, - 6043, 6044, 2229, 6045, 6046, 6047, 2252, 2234, - 6048, 2214, 2216, 2253, 2254, 6049, 2220, 6050, - 6051, 2239, 6052, 6053, 6054, 6055, 6056, 6057, - 6058, 6059, 6060, 6061, 6062, 6033, 2233, 2208, - 2251, 2235, 2236, 6034, 2215, 2218, 6035, 6036, - 2219, 2238, 2221, 6037, 2223, 2224, 2225, 6038, - 6039, 6040, 6041, 6042, 6043, 6044, 2229, 6045, - 6046, 6047, 2252, 2234, 6048, 2214, 2216, 2253, - 2254, 6049, 2220, 6050, 6051, 2239, 6052, 6053, - 6054, 6055, 6056, 6057, 6058, 6059, 6060, 6061, - 6062, 6033, 2233, 2208, 2251, 2235, 2236, 6034, - 2215, 2218, 6035, 6036, 2219, 2238, 2221, 6037, - 2223, 2224, 2225, 6038, 6039, 6040, 6041, 6042, - 6043, 6044, 2229, 6045, 6046, 6047, 2252, 2234, - 6048, 2214, 2216, 2253, 2254, 6049, 2220, 6050, - 6051, 2239, 6052, 6053, 6054, 6055, 6056, 6057, - 6058, 6059, 6060, 6061, 6062, 6063, 6064, 0, - 0, 6065, 6066, 2248, 6067, 6068, 6069, 6070, - 6071, 6072, 6073, 6074, 6075, 6076, 6077, 6078, - 2249, 6079, 6080, 6081, 6082, 6083, 6084, 6085, - 6086, 6087, 6088, 6089, 6090, 2247, 6091, 6092, - 6093, 6094, 6095, 6096, 6097, 6098, 6099, 6100, - 6101, 6102, 2246, 6103, 6104, 6105, 6106, 6107, - 6108, 6109, 6110, 6111, 6112, 6113, 6114, 6115, - 6116, 6117, 6118, 6065, 6066, 2248, 6067, 6068, - 6069, 6070, 6071, 6072, 6073, 6074, 6075, 6076, - 6077, 6078, 2249, 6079, 6080, 6081, 6082, 6083, - 6084, 6085, 6086, 6087, 6088, 6089, 6090, 2247, - 6091, 6092, 6093, 6094, 6095, 6096, 6097, 6098, - 6099, 6100, 6101, 6102, 2246, 6103, 6104, 6105, - 6106, 6107, 6108, 6109, 6110, 6111, 6112, 6113, - 6114, 6115, 6116, 6117, 6118, 6065, 6066, 2248, - 6067, 6068, 6069, 6070, 6071, 6072, 6073, 6074, - 6075, 6076, 6077, 6078, 2249, 6079, 6080, 6081, - 6082, 6083, 6084, 6085, 6086, 6087, 6088, 6089, - 6090, 2247, 6091, 6092, 6093, 6094, 6095, 6096, - 6097, 6098, 6099, 6100, 6101, 6102, 2246, 6103, - 6104, 6105, 6106, 6107, 6108, 6109, 6110, 6111, - 6112, 6113, 6114, 6115, 6116, 6117, 6118, 6065, - 6066, 2248, 6067, 6068, 6069, 6070, 6071, 6072, - 6073, 6074, 6075, 6076, 6077, 6078, 2249, 6079, - 6080, 6081, 6082, 6083, 6084, 6085, 6086, 6087, - 6088, 6089, 6090, 2247, 6091, 6092, 6093, 6094, - 6095, 6096, 6097, 6098, 6099, 6100, 6101, 6102, - 2246, 6103, 6104, 6105, 6106, 6107, 6108, 6109, - 6110, 6111, 6112, 6113, 6114, 6115, 6116, 6117, - 6118, 6065, 6066, 2248, 6067, 6068, 6069, 6070, - 6071, 6072, 6073, 6074, 6075, 6076, 6077, 6078, - 2249, 6079, 6080, 6081, 6082, 6083, 6084, 6085, - 6086, 6087, 6088, 6089, 6090, 2247, 6091, 6092, - 6093, 6094, 6095, 6096, 6097, 6098, 6099, 6100, - 6101, 6102, 2246, 6103, 6104, 6105, 6106, 6107, - 6108, 6109, 6110, 6111, 6112, 6113, 6114, 6115, - 6116, 6117, 6118, 6119, 6120, 0, 0, 6121, - 6122, 6123, 6124, 6125, 6126, 6127, 6128, 6129, - 6130, 6121, 6122, 6123, 6124, 6125, 6126, 6127, - 6128, 6129, 6130, 6121, 6122, 6123, 6124, 6125, - 6126, 6127, 6128, 6129, 6130, 6121, 6122, 6123, - 6124, 6125, 6126, 6127, 6128, 6129, 6130, 6121, - 6122, 6123, 6124, 6125, 6126, 6127, 6128, 6129, - 6130, 1151, 1151, 1151, 1151, 1151, 1151, 1151, - 1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, - 1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, - 1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, - 1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, - 1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, - 1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, - 841, 841, 841, 841, 1151, 1151, 1151, 1151, - 1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, - 1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, - 1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, - 1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, - 1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, - 1151, 1151, 1151, 1151, 1151, 1151, 841, 841, - 841, 841, 841, 841, 841, 841, 1151, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 1151, 841, 841, - 1047, 1047, 1047, 1047, 1047, 0, 0, 0, + 0, 0, 0, 0, 0, 3227, 3227, 3227, + 3227, 0, 0, 0, 0, 0, 0, 0, + 0, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 0, 0, 913, 1225, 640, + 1119, 1538, 1538, 1538, 1538, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 0, + 0, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1151, 1151, 1151, 1151, - 1151, 0, 1151, 1151, 1151, 1151, 1151, 1151, - 1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, - 1151, 0, 0, 0, 0, 0, 0, 0, + 0, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 0, 0, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 6414, 6415, 913, 913, 913, 913, 913, 6416, + 6417, 6418, 6419, 6420, 6421, 6422, 6423, 6424, + 640, 640, 640, 913, 913, 913, 6425, 6426, + 6427, 6428, 6429, 6430, 1538, 1538, 1538, 1538, + 1538, 1538, 1538, 1538, 627, 627, 627, 627, + 627, 627, 627, 627, 913, 913, 614, 614, + 614, 614, 614, 627, 627, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 614, 614, 614, 614, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 6431, 6432, 6433, 6434, 6435, 6436, + 6437, 6438, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 76, 76, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 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, 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, 614, 614, 614, 76, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -6042,12 +6342,6 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 543, 543, 543, 543, 543, 543, 543, - 0, 543, 543, 543, 543, 543, 543, 543, - 543, 543, 543, 543, 543, 543, 543, 543, - 543, 543, 0, 0, 543, 543, 543, 543, - 543, 543, 543, 0, 543, 543, 0, 543, - 543, 543, 543, 543, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -6056,9 +6350,30 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1258, 1258, 1258, 1258, 1258, 1258, 1258, + 1258, 1258, 1258, 1258, 1258, 1258, 1258, 1258, + 1258, 1258, 1258, 1258, 1258, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1258, 1258, 1258, 1258, 1258, 1258, 1258, + 1258, 1258, 1258, 1258, 1258, 1258, 1258, 1258, + 1258, 1258, 1258, 1258, 1258, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 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, 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, 76, + 76, 76, 76, 76, 76, 76, 76, 76, + 76, 76, 76, 76, 76, 76, 76, 76, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1258, 1258, 1258, 1258, 1258, 1258, 1258, + 1258, 1258, 1258, 1258, 1258, 1258, 1258, 1258, + 1258, 1258, 1258, 1258, 1258, 1258, 1258, 1258, + 1258, 1258, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -6074,19 +6389,158 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 0, 0, - 0, 543, 543, 543, 543, 543, 543, 543, - 525, 525, 525, 525, 525, 525, 525, 0, - 0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 0, 0, 0, 0, 341, - 841, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 6439, 6440, 6441, 6442, 6443, 6444, 6445, + 6446, 6447, 6448, 6449, 6450, 6451, 6452, 6453, + 6454, 6455, 6456, 6457, 6458, 6459, 6460, 6461, + 6462, 6463, 6464, 6465, 6466, 6467, 6468, 6469, + 6470, 6471, 6472, 6473, 6474, 6475, 6476, 6477, + 6478, 6479, 6480, 6481, 6482, 6483, 6484, 6485, + 6486, 6487, 6488, 6489, 6490, 6491, 6492, 6493, + 6494, 6495, 6496, 6497, 6498, 6499, 6500, 6501, + 6502, 6503, 6504, 6505, 6506, 6507, 6508, 6509, + 6510, 6511, 6512, 6513, 6514, 6515, 6516, 6517, + 6518, 6519, 6520, 6521, 6522, 6523, 0, 6524, + 6525, 6526, 6527, 6528, 6529, 6530, 6531, 6532, + 6533, 6534, 6535, 6536, 6537, 6538, 6539, 6540, + 6541, 6542, 6543, 6544, 6545, 6546, 6547, 6548, + 6549, 6550, 6551, 6552, 6553, 6554, 6555, 6556, + 6557, 6558, 6559, 6560, 6561, 6562, 6563, 6564, + 6565, 6566, 6567, 6568, 6569, 6570, 6571, 6572, + 6573, 6574, 6575, 6576, 6577, 6578, 6579, 6580, + 6581, 6582, 6583, 6584, 6585, 6586, 6587, 6588, + 6589, 6590, 6591, 6592, 6593, 6594, 0, 6595, + 6596, 0, 0, 6597, 0, 0, 6598, 6599, + 0, 0, 6600, 6601, 6602, 6603, 0, 6604, + 6605, 6606, 6607, 6608, 6609, 6610, 6611, 6612, + 6613, 6614, 6615, 0, 6616, 0, 6617, 6618, + 6619, 6620, 6621, 6622, 6623, 0, 6624, 6625, + 6626, 6627, 6628, 6629, 6630, 6631, 6632, 6633, + 6634, 6635, 6636, 6637, 6638, 6639, 6640, 6641, + 6642, 6643, 6644, 6645, 6646, 6647, 6648, 6649, + 6650, 6651, 6652, 6653, 6654, 6655, 6656, 6657, + 6658, 6659, 6660, 6661, 6662, 6663, 6664, 6665, + 6666, 6667, 6668, 6669, 6670, 6671, 6672, 6673, + 6674, 6675, 6676, 6677, 6678, 6679, 6680, 6681, + 6682, 6683, 6684, 6685, 6686, 6687, 6688, 0, + 6689, 6690, 6691, 6692, 0, 0, 6693, 6694, + 6695, 6696, 6697, 6698, 6699, 6700, 0, 6701, + 6702, 6703, 6704, 6705, 6706, 6707, 0, 6708, + 6709, 6710, 6711, 6712, 6713, 6714, 6715, 6716, + 6717, 6718, 6719, 6720, 6721, 6722, 6723, 6724, + 6725, 6726, 6727, 6728, 6729, 6730, 6731, 6732, + 6733, 6734, 6735, 0, 6736, 6737, 6738, 6739, + 0, 6740, 6741, 6742, 6743, 6744, 0, 6745, + 0, 0, 0, 6746, 6747, 6748, 6749, 6750, + 6751, 6752, 0, 6753, 6754, 6755, 6756, 6757, + 6758, 6759, 6760, 6761, 6762, 6763, 6764, 6765, + 6766, 6767, 6768, 6769, 6770, 6771, 6772, 6773, + 6774, 6775, 6776, 6777, 6778, 6779, 6780, 6781, + 6782, 6783, 6784, 6785, 6786, 6787, 6788, 6789, + 6790, 6791, 6792, 6793, 6794, 6795, 6796, 6797, + 6798, 6799, 6800, 6801, 6802, 6803, 6804, 6805, + 6806, 6807, 6808, 6809, 6810, 6811, 6812, 6813, + 6814, 6815, 6816, 6817, 6818, 6819, 6820, 6821, + 6822, 6823, 6824, 6825, 6826, 6827, 6828, 6829, + 6830, 6831, 6832, 6833, 6834, 6835, 6836, 6837, + 6838, 6839, 6840, 6841, 6842, 6843, 6844, 6845, + 6846, 6847, 6848, 6849, 6850, 6851, 6852, 6853, + 6854, 6855, 6856, 6857, 6858, 6859, 6860, 6861, + 6862, 6863, 6864, 6865, 6866, 6867, 6868, 6869, + 6870, 6871, 6872, 6873, 6874, 6875, 6876, 6877, + 6878, 6879, 6880, 6881, 6882, 6883, 6884, 6885, + 6886, 6887, 6888, 6889, 6890, 6891, 6892, 6893, + 6894, 6895, 6896, 6897, 6898, 6899, 6900, 6901, + 6902, 6903, 6904, 6905, 6906, 6907, 6908, 6909, + 6910, 6911, 6912, 6913, 6914, 6915, 6916, 6917, + 6918, 6919, 6920, 6921, 6922, 6923, 6924, 6925, + 6926, 6927, 6928, 6929, 6930, 6931, 6932, 6933, + 6934, 6935, 6936, 6937, 6938, 6939, 6940, 6941, + 6942, 6943, 6944, 6945, 6946, 6947, 6948, 6949, + 6950, 6951, 6952, 6953, 6954, 6955, 6956, 6957, + 6958, 6959, 6960, 6961, 6962, 6963, 6964, 6965, + 6966, 6967, 6968, 6969, 6970, 6971, 6972, 6973, + 6974, 6975, 6976, 6977, 6978, 6979, 6980, 6981, + 6982, 6983, 6984, 6985, 6986, 6987, 6988, 6989, + 6990, 6991, 6992, 6993, 6994, 6995, 6996, 6997, + 6998, 6999, 7000, 7001, 7002, 7003, 7004, 7005, + 7006, 7007, 7008, 7009, 7010, 7011, 7012, 7013, + 7014, 7015, 7016, 7017, 7018, 7019, 7020, 7021, + 7022, 7023, 7024, 7025, 7026, 7027, 7028, 7029, + 7030, 7031, 7032, 7033, 7034, 7035, 7036, 7037, + 7038, 7039, 7040, 7041, 7042, 7043, 7044, 7045, + 7046, 7047, 7048, 7049, 7050, 7051, 7052, 7053, + 7054, 7055, 7056, 7057, 7058, 7059, 7060, 7061, + 7062, 7063, 7064, 7065, 7066, 7067, 7068, 7069, + 7070, 7071, 7072, 7073, 7074, 7075, 7076, 7077, + 7078, 7079, 7080, 7081, 7082, 7083, 7084, 7085, + 7086, 7087, 7088, 7089, 7090, 7091, 7092, 0, + 0, 7093, 7094, 7095, 7096, 7097, 7098, 7099, + 7100, 7101, 7102, 7103, 7104, 7105, 7106, 7107, + 7108, 7109, 7110, 7111, 7112, 7113, 7114, 7115, + 7116, 7117, 7118, 7119, 7120, 7121, 7122, 7123, + 7124, 7125, 7126, 7127, 7128, 7129, 7130, 7131, + 7132, 7133, 7134, 7135, 7136, 7137, 7138, 7139, + 7140, 7141, 7142, 7143, 7144, 7145, 7146, 7147, + 7148, 7149, 7150, 7151, 7152, 7153, 7154, 7155, + 7156, 7157, 7158, 7159, 7160, 7161, 7162, 7163, + 7164, 7165, 7166, 7167, 7168, 7169, 7170, 7171, + 7172, 7173, 7174, 7175, 7118, 7176, 7177, 7178, + 7179, 7180, 7181, 7182, 7183, 7184, 7185, 7186, + 7187, 7188, 7189, 7190, 7191, 7192, 7193, 7194, + 7195, 7196, 7197, 7198, 7199, 7200, 7144, 7201, + 7202, 7203, 7204, 7205, 7206, 7207, 7208, 7209, + 7210, 7211, 7212, 7213, 7214, 7215, 7216, 7217, + 7218, 7219, 7220, 7221, 7222, 7223, 7224, 7225, + 7226, 7227, 7228, 7229, 7230, 7231, 7118, 7232, + 7233, 7234, 7235, 7236, 7237, 7238, 7239, 7240, + 7241, 7242, 7243, 7244, 7245, 7246, 7247, 7248, + 7249, 7250, 7251, 7252, 7253, 7254, 7255, 7256, + 7144, 7257, 7258, 7259, 7260, 7261, 7262, 7263, + 7264, 7265, 7266, 7267, 7268, 7269, 7270, 7271, + 7272, 7273, 7274, 7275, 7276, 7277, 7278, 7279, + 7280, 7281, 7282, 7283, 7284, 7285, 7286, 7287, + 7118, 7288, 7289, 7290, 7291, 7292, 7293, 7294, + 7295, 7296, 7297, 7298, 7299, 7300, 7301, 7302, + 7303, 7304, 7305, 7306, 7307, 7308, 7309, 7310, + 7311, 7312, 7144, 7313, 7314, 7315, 7316, 7317, + 7318, 7319, 7320, 7321, 7322, 7323, 7324, 7325, + 7326, 7327, 7328, 7329, 7330, 7331, 7332, 7333, + 7334, 7335, 7336, 7337, 7338, 7339, 7340, 7341, + 7342, 7343, 7118, 7344, 7345, 7346, 7347, 7348, + 7349, 7350, 7351, 7352, 7353, 7354, 7355, 7356, + 7357, 7358, 7359, 7360, 7361, 7362, 7363, 7364, + 7365, 7366, 7367, 7368, 7144, 7369, 7370, 7371, + 7372, 7373, 7374, 7375, 7376, 0, 0, 7377, + 7378, 7379, 7380, 7381, 7382, 7383, 7384, 7385, + 7386, 7377, 7378, 7379, 7380, 7381, 7382, 7383, + 7384, 7385, 7386, 7377, 7378, 7379, 7380, 7381, + 7382, 7383, 7384, 7385, 7386, 7377, 7378, 7379, + 7380, 7381, 7382, 7383, 7384, 7385, 7386, 7377, + 7378, 7379, 7380, 7381, 7382, 7383, 7384, 7385, + 7386, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 913, 913, 913, 913, 1225, 1225, 1225, 1225, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 1225, 1225, 1225, 1225, 1225, 913, 913, + 913, 913, 913, 913, 913, 913, 1225, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 1225, 913, 913, + 1119, 1119, 1119, 1119, 1119, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1225, 1225, 1225, 1225, + 1225, 0, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, + 1225, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -6096,6 +6550,12 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 7387, 7388, 7389, 7390, 7391, 7392, 7393, + 7394, 7395, 7396, 345, 7397, 7398, 7399, 7400, + 7401, 7402, 7403, 7404, 7405, 7406, 7407, 7408, + 7409, 7410, 7411, 7412, 7413, 7414, 7415, 7416, + 0, 0, 0, 0, 0, 0, 7417, 7418, + 7419, 7420, 7421, 7422, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -6122,71 +6582,49 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 614, 614, 614, 614, 614, 614, 614, + 0, 614, 614, 614, 614, 614, 614, 614, + 614, 614, 614, 614, 614, 614, 614, 614, + 614, 614, 0, 0, 614, 614, 614, 614, + 614, 614, 614, 0, 614, 614, 0, 614, + 614, 614, 614, 614, 0, 0, 0, 0, + 0, 7423, 7424, 7425, 7426, 7427, 7428, 7429, + 7430, 7431, 7432, 7433, 7434, 7435, 7436, 7437, + 7438, 7439, 7440, 7441, 7442, 7443, 7444, 7445, + 7446, 7447, 7448, 7449, 7450, 7451, 7452, 7453, + 7454, 7455, 7456, 7457, 7458, 7459, 7460, 7461, + 7462, 7463, 7464, 7465, 7466, 7467, 7468, 7469, + 7470, 7471, 7472, 7473, 7474, 7475, 7476, 7477, + 7478, 7479, 7480, 7481, 7482, 7483, 7484, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 614, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 543, 543, 543, - 543, 1172, 1172, 1172, 1172, 1172, 1172, 1172, - 1172, 1172, 1172, 0, 0, 0, 0, 0, - 11, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, - 1108, 1108, 1108, 1108, 1108, 1108, 0, 0, - 5741, 5741, 5741, 5741, 5741, 5741, 5741, 5741, - 5741, 556, 556, 556, 556, 556, 556, 556, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 6131, 6132, 6133, 6134, 6135, 6136, 6137, - 6138, 6139, 6140, 6141, 6142, 6143, 6144, 6145, - 6146, 6147, 6148, 6149, 6150, 6151, 6152, 6153, - 6154, 6155, 6156, 6157, 6158, 6159, 6160, 6161, - 6162, 6163, 6164, 6165, 6166, 6167, 6168, 6169, - 6170, 6171, 6172, 6173, 6174, 6175, 6176, 6177, - 6178, 6179, 6180, 6181, 6182, 6183, 6184, 6185, - 6186, 6187, 6188, 6189, 6190, 6191, 6192, 6193, - 6194, 6195, 6196, 6197, 6198, 543, 543, 543, - 543, 543, 543, 1173, 1153, 0, 0, 0, - 0, 1152, 1152, 1152, 1152, 1152, 1152, 1152, - 1152, 1152, 1152, 0, 0, 0, 0, 1105, - 1105, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 0, 0, + 0, 614, 614, 614, 614, 614, 614, 614, + 595, 595, 595, 595, 595, 595, 595, 0, + 0, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 0, 0, 0, 0, 345, + 913, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -6216,15 +6654,6 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 5846, 5846, 5846, 5846, 5846, 5846, - 5846, 5846, 5846, 5846, 5846, 5846, 5846, 5846, - 5846, 5846, 5846, 5846, 5846, 5846, 5846, 5846, - 5846, 5846, 5846, 5846, 5846, 5846, 5846, 5846, - 5846, 5846, 5846, 5846, 5846, 5846, 5846, 5846, - 5846, 5846, 5846, 5846, 5846, 5846, 5846, 5846, - 5846, 5846, 5846, 5846, 5846, 5846, 5846, 5846, - 5846, 5846, 5846, 5846, 5846, 1148, 5846, 5846, - 5846, 1111, 5846, 5846, 5846, 5846, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -6234,17 +6663,22 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 5846, 5846, 5846, 5846, 5846, 5846, - 5846, 5846, 5846, 5846, 5846, 5846, 5846, 5846, - 5846, 5846, 5846, 5846, 5846, 5846, 5846, 5846, - 5846, 5846, 5846, 5846, 5846, 5846, 5846, 5846, - 5846, 5846, 5846, 5846, 5846, 5846, 5846, 5846, - 5846, 5846, 5846, 5846, 5846, 5846, 5846, 1148, - 5846, 5846, 5846, 5846, 5846, 5846, 5846, 5846, - 5846, 5846, 5846, 5846, 5846, 5846, 5846, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 614, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 614, 614, 614, + 614, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 0, 0, 0, 0, 0, + 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -6266,620 +6700,852 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 6199, 6200, 6201, 6202, 0, 6203, 6204, - 6205, 6206, 6207, 6208, 6209, 6210, 6211, 6212, - 6213, 6214, 6215, 6216, 6217, 6218, 6219, 6220, - 6221, 6222, 6223, 6224, 6225, 6226, 6227, 6228, - 6229, 0, 6200, 6201, 0, 6230, 0, 0, - 6205, 0, 6207, 6208, 6209, 6210, 6211, 6212, - 6213, 6214, 6215, 6216, 0, 6218, 6219, 6220, - 6221, 0, 6223, 0, 6225, 0, 0, 0, - 0, 0, 0, 6201, 0, 0, 0, 0, - 6205, 0, 6207, 0, 6209, 0, 6211, 6212, - 6213, 0, 6215, 6216, 0, 6218, 0, 0, - 6221, 0, 6223, 0, 6225, 0, 6227, 0, - 6229, 0, 6200, 6201, 0, 6230, 0, 0, - 6205, 6206, 6207, 6208, 0, 6210, 6211, 6212, - 6213, 6214, 6215, 6216, 0, 6218, 6219, 6220, - 6221, 0, 6223, 6224, 6225, 6226, 0, 6228, - 0, 6199, 6200, 6201, 6202, 6230, 6203, 6204, - 6205, 6206, 6207, 0, 6209, 6210, 6211, 6212, - 6213, 6214, 6215, 6216, 6217, 6218, 6219, 6220, - 6221, 6222, 6223, 6224, 6225, 0, 0, 0, - 0, 0, 6200, 6201, 6202, 0, 6203, 6204, - 6205, 6206, 6207, 0, 6209, 6210, 6211, 6212, - 6213, 6214, 6215, 6216, 6217, 6218, 6219, 6220, - 6221, 6222, 6223, 6224, 6225, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 595, 626, 626, 627, + 614, 1248, 1248, 1248, 1248, 1248, 1248, 1248, + 1248, 1248, 1248, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 345, 345, 345, 345, 345, 345, 345, + 0, 345, 345, 345, 345, 0, 345, 345, + 0, 345, 345, 345, 345, 345, 345, 345, + 345, 345, 345, 345, 345, 345, 345, 345, + 0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, + 1182, 1182, 1182, 1182, 1182, 1182, 0, 0, + 6143, 6143, 6143, 6143, 6143, 6143, 6143, 6143, + 6143, 627, 627, 627, 627, 627, 627, 627, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 7485, 7486, 7487, 7488, 7489, 7490, 7491, + 7492, 7493, 7494, 7495, 7496, 7497, 7498, 7499, + 7500, 7501, 7502, 7503, 7504, 7505, 7506, 7507, + 7508, 7509, 7510, 7511, 7512, 7513, 7514, 7515, + 7516, 7517, 7518, 7519, 7520, 7521, 7522, 7523, + 7524, 7525, 7526, 7527, 7528, 7529, 7530, 7531, + 7532, 7533, 7534, 7535, 7536, 7537, 7538, 7539, + 7540, 7541, 7542, 7543, 7544, 7545, 7546, 7547, + 7548, 7549, 7550, 7551, 7552, 614, 614, 614, + 614, 614, 614, 1249, 1227, 0, 0, 0, + 0, 1226, 1226, 1226, 1226, 1226, 1226, 1226, + 1226, 1226, 1226, 0, 0, 0, 0, 1179, + 1179, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 6248, 6248, 6248, 6248, 6248, 6248, + 6248, 6248, 6248, 6248, 6248, 6248, 6248, 6248, + 6248, 6248, 6248, 6248, 6248, 6248, 6248, 6248, + 6248, 6248, 6248, 6248, 6248, 6248, 6248, 6248, + 6248, 6248, 6248, 6248, 6248, 6248, 6248, 6248, + 6248, 6248, 6248, 6248, 6248, 6248, 6248, 6248, + 6248, 6248, 6248, 6248, 6248, 6248, 6248, 6248, + 6248, 6248, 6248, 6248, 6248, 1222, 6248, 6248, + 6248, 1185, 6248, 6248, 6248, 6248, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 6248, 6248, 6248, 6248, 6248, 6248, + 6248, 6248, 6248, 6248, 6248, 6248, 6248, 6248, + 6248, 6248, 6248, 6248, 6248, 6248, 6248, 6248, + 6248, 6248, 6248, 6248, 6248, 6248, 6248, 6248, + 6248, 6248, 6248, 6248, 6248, 6248, 6248, 6248, + 6248, 6248, 6248, 6248, 6248, 6248, 6248, 1222, + 6248, 6248, 6248, 6248, 6248, 6248, 6248, 6248, + 6248, 6248, 6248, 6248, 6248, 6248, 6248, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 7553, 7554, 7555, 7556, 0, 7557, 7558, + 7559, 7560, 7561, 7562, 7563, 7564, 7565, 7566, + 7567, 7568, 7569, 7570, 7571, 7572, 7573, 7574, + 7575, 7576, 7577, 7578, 7579, 7580, 7581, 7582, + 7583, 0, 7554, 7555, 0, 7584, 0, 0, + 7559, 0, 7561, 7562, 7563, 7564, 7565, 7566, + 7567, 7568, 7569, 7570, 0, 7572, 7573, 7574, + 7575, 0, 7577, 0, 7579, 0, 0, 0, + 0, 0, 0, 7555, 0, 0, 0, 0, + 7559, 0, 7561, 0, 7563, 0, 7565, 7566, + 7567, 0, 7569, 7570, 0, 7572, 0, 0, + 7575, 0, 7577, 0, 7579, 0, 7581, 0, + 7583, 0, 7554, 7555, 0, 7584, 0, 0, + 7559, 7560, 7561, 7562, 0, 7564, 7565, 7566, + 7567, 7568, 7569, 7570, 0, 7572, 7573, 7574, + 7575, 0, 7577, 7578, 7579, 7580, 0, 7582, + 0, 7553, 7554, 7555, 7556, 7584, 7557, 7558, + 7559, 7560, 7561, 0, 7563, 7564, 7565, 7566, + 7567, 7568, 7569, 7570, 7571, 7572, 7573, 7574, + 7575, 7576, 7577, 7578, 7579, 0, 0, 0, + 0, 0, 7554, 7555, 7556, 0, 7557, 7558, + 7559, 7560, 7561, 0, 7563, 7564, 7565, 7566, + 7567, 7568, 7569, 7570, 7571, 7572, 7573, 7574, + 7575, 7576, 7577, 7578, 7579, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 74, 74, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 78, 78, 78, 78, 2579, 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, 0, 0, 0, + 0, 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, + 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, 78, + 78, 78, 78, 78, 78, 78, 78, 78, + 78, 78, 78, 78, 78, 78, 78, 78, + 78, 78, 78, 78, 78, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 78, 78, 78, 78, 78, 78, 78, + 78, 78, 78, 78, 78, 78, 78, 78, + 0, 0, 78, 78, 78, 78, 78, 78, + 78, 78, 78, 78, 78, 78, 78, 78, + 78, 0, 78, 78, 78, 78, 78, 78, + 78, 78, 78, 78, 78, 78, 78, 78, + 2579, 0, 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, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 7585, 7586, 7587, 7588, 7589, 7590, 7591, + 7592, 7593, 7594, 7595, 1288, 1288, 78, 78, + 78, 7596, 7597, 7598, 7599, 7600, 7601, 7602, + 7603, 7604, 7605, 7606, 7607, 7608, 7609, 7610, + 7611, 7612, 7613, 7614, 7615, 7616, 7617, 7618, + 7619, 7620, 7621, 7622, 7623, 7624, 7625, 7626, + 78, 7627, 7628, 7629, 7630, 7631, 7632, 7633, + 7634, 7635, 7636, 7637, 7638, 7639, 7640, 7641, + 7642, 7643, 7644, 7645, 7646, 7647, 7648, 7649, + 7650, 7651, 7652, 7653, 7654, 7655, 7656, 7657, + 7658, 7659, 7660, 7661, 7662, 7663, 7664, 7665, + 7666, 7667, 7668, 7669, 7670, 7671, 7672, 7673, + 7674, 7675, 7676, 7677, 7678, 7679, 7680, 7681, + 7682, 7683, 7684, 7685, 7686, 7687, 78, 78, + 78, 7688, 7689, 7690, 7691, 7692, 7693, 7694, + 7695, 7696, 7697, 7698, 7699, 7700, 7701, 7702, + 7703, 7704, 7705, 7706, 7707, 7708, 7709, 7710, + 7711, 7712, 7713, 913, 913, 913, 913, 7714, + 913, 7715, 7714, 7714, 7714, 7714, 7714, 7714, + 7714, 7714, 7714, 7714, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 913, 913, + 913, 913, 913, 913, 913, 913, 78, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 7716, + 7716, 7716, 7716, 7716, 7716, 7716, 7716, 7716, + 7716, 7716, 7716, 7716, 7716, 7716, 7716, 7716, + 7716, 7716, 7716, 7716, 7716, 7716, 7716, 7716, + 7716, 7717, 7718, 7719, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 7720, 7721, 7722, 7723, 7724, 7725, 7726, + 7727, 7728, 7729, 7730, 7731, 7732, 7733, 7734, + 7735, 7736, 7737, 7738, 7739, 7740, 7741, 7742, + 7743, 7744, 7745, 7746, 7747, 7748, 7749, 7750, + 7751, 7752, 7753, 7754, 7755, 7756, 7757, 7758, + 7759, 7760, 7761, 7762, 7763, 0, 0, 0, + 0, 7764, 7765, 7766, 7767, 7768, 7769, 7770, + 7771, 7772, 0, 0, 0, 0, 0, 0, + 0, 7773, 7774, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 2579, 2579, 2579, 2579, 2579, 2579, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 78, 78, 78, 78, 78, 78, + 78, 78, 78, 78, 78, 78, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 78, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 78, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 78, 78, 78, + 78, 78, 78, 78, 78, 78, 78, 78, + 78, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 78, 78, 78, 78, + 2579, 2579, 2579, 2579, 2579, 78, 78, 78, + 78, 78, 78, 78, 78, 78, 78, 78, + 78, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 78, 78, 78, 2579, 78, 78, + 78, 2579, 2579, 2579, 7775, 7775, 7775, 7775, + 7775, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 78, 2579, 78, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 78, 78, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 76, + 76, 76, 76, 76, 76, 76, 76, 78, + 78, 78, 78, 78, 2579, 2579, 2579, 2579, + 78, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 78, 78, 78, 78, 78, 78, 78, + 78, 78, 78, 78, 78, 78, 78, 78, + 78, 78, 78, 2579, 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, 2579, 2579, + 78, 78, 78, 78, 78, 78, 78, 78, + 78, 78, 78, 78, 78, 2579, 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, 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, 78, 78, 78, 78, + 78, 78, 78, 78, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 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, 76, 76, 76, 76, + 76, 76, 76, 76, 76, 76, 76, 76, + 76, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 78, + 78, 78, 78, 78, 78, 2579, 78, 78, + 78, 2579, 2579, 2579, 78, 78, 2579, 2579, + 2579, 0, 0, 0, 0, 2579, 2579, 2579, + 2579, 78, 78, 78, 78, 78, 78, 78, + 78, 78, 78, 78, 2579, 2579, 0, 0, + 0, 78, 78, 78, 78, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 0, 0, + 0, 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, 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, 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, 76, 76, 76, 76, 76, 76, + 76, 76, 76, 76, 76, 78, 78, 78, + 0, 0, 0, 0, 78, 78, 78, 78, + 78, 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, 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, 76, + 76, 76, 76, 76, 76, 76, 76, 76, + 76, 76, 76, 76, 76, 76, 78, 78, + 78, 78, 78, 0, 0, 0, 0, 0, + 0, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 0, 0, 0, + 0, 2579, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 76, 76, 76, 76, 76, 76, 76, + 76, 76, 76, 76, 76, 0, 0, 0, + 0, 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, 76, 76, 76, 76, + 76, 76, 76, 76, 76, 76, 76, 76, + 76, 76, 76, 76, 76, 76, 76, 76, + 76, 0, 0, 0, 0, 0, 0, 0, + 0, 76, 76, 76, 76, 76, 76, 76, + 76, 76, 76, 0, 0, 0, 0, 0, + 0, 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, 76, 76, 76, 76, + 76, 0, 0, 0, 0, 0, 0, 0, + 0, 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, 0, + 0, 78, 78, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 76, 76, 76, 76, 76, 76, 76, + 76, 76, 76, 76, 76, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 76, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 76, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 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, + 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, 78, + 78, 78, 78, 78, 78, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 78, 78, 78, 78, 78, 78, 78, + 78, 78, 78, 78, 78, 78, 78, 0, + 0, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 0, 0, + 0, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 0, 0, 0, 0, 0, 0, + 0, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 0, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 0, + 0, 0, 0, 0, 0, 0, 0, 2579, + 2579, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 2579, 2579, 2579, 0, 0, 0, + 0, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 0, 0, 0, 0, 0, 0, + 0, 2579, 2579, 2579, 2579, 2579, 2579, 2579, + 2579, 2579, 0, 0, 0, 0, 0, 0, + 0, 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, 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, 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, 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, 76, 76, 76, + 76, 76, 76, 76, 0, 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, + 76, 76, 76, 76, 76, 76, 76, 76, + 76, 76, 76, 76, 76, 76, 76, 76, + 76, 76, 76, 76, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 7377, 7378, 7379, 7380, 7381, 7382, 7383, + 7384, 7385, 7386, 0, 0, 0, 0, 0, + 0, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 0, 0, 0, 0, 0, + 0, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 0, + 0, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 75, 75, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 79, 79, 79, 79, 2397, 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, 0, 0, 0, - 0, 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, - 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, 79, - 79, 79, 79, 79, 79, 79, 79, 79, - 79, 79, 79, 79, 79, 79, 79, 79, - 79, 79, 79, 79, 79, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 79, 79, 79, 79, 79, 79, 79, - 79, 79, 79, 79, 79, 79, 79, 79, - 0, 0, 79, 79, 79, 79, 79, 79, - 79, 79, 79, 79, 79, 79, 79, 79, - 79, 0, 79, 79, 79, 79, 79, 79, - 79, 79, 79, 79, 79, 79, 79, 79, - 2397, 0, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 6231, 6232, 6233, 6234, 6235, 6236, 6237, - 6238, 6239, 6240, 6241, 1211, 1211, 0, 0, - 0, 6242, 6243, 6244, 6245, 6246, 6247, 6248, - 6249, 6250, 6251, 6252, 6253, 6254, 6255, 6256, - 6257, 6258, 6259, 6260, 6261, 6262, 6263, 6264, - 6265, 6266, 6267, 6268, 6269, 6270, 6271, 6272, - 79, 6273, 6274, 6275, 6276, 6277, 6278, 6279, - 6280, 6281, 6282, 6283, 6284, 6285, 6286, 6287, - 6288, 6289, 6290, 6291, 6292, 6293, 6294, 6295, - 6296, 6297, 6298, 6299, 6300, 6301, 6302, 6303, - 6304, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 6305, 6306, 6307, 0, 0, - 0, 2541, 2541, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 2541, - 2541, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 6308, - 841, 6309, 6308, 6308, 6308, 6308, 6308, 6308, - 6308, 6308, 6308, 6308, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 841, 841, - 841, 841, 841, 841, 841, 841, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 6310, - 6310, 6310, 6310, 6310, 6310, 6310, 6310, 6310, - 6310, 6310, 6310, 6310, 6310, 6310, 6310, 6310, - 6310, 6310, 6310, 6310, 6310, 6310, 6310, 6310, - 6310, 6311, 6312, 6313, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 6314, 6315, 6316, 6317, 6318, 6319, 6320, - 6321, 6322, 6323, 6324, 6325, 6326, 6327, 6328, - 6329, 6330, 6331, 6332, 6333, 6334, 6335, 6336, - 6337, 6338, 6339, 6340, 6341, 6342, 6343, 6344, - 6345, 6346, 6347, 6348, 6349, 6350, 6351, 6352, - 6353, 6354, 6355, 6356, 6357, 0, 0, 0, - 0, 6358, 6359, 6360, 6361, 6362, 6363, 6364, - 6365, 6366, 0, 0, 0, 0, 0, 0, - 0, 6367, 6368, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 2397, 2397, 2397, 2397, 2397, 2397, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 79, 79, 79, 79, 79, 79, - 79, 79, 79, 79, 79, 79, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 79, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 79, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 79, 79, 79, - 79, 79, 79, 79, 79, 79, 79, 79, - 79, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 79, 79, 79, 79, - 2397, 2397, 2397, 2397, 2397, 79, 79, 79, - 79, 79, 79, 79, 79, 79, 79, 79, - 79, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 79, 79, 79, 2397, 79, 79, - 79, 2397, 2397, 2397, 6369, 6369, 6369, 6369, - 6369, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 79, 2397, 79, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 79, 79, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 77, - 77, 77, 77, 77, 77, 77, 77, 79, - 79, 79, 79, 79, 2397, 2397, 2397, 2397, - 79, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 79, 79, 79, 79, 79, 79, 79, - 79, 79, 79, 79, 79, 79, 79, 79, - 79, 79, 79, 2397, 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, 2397, 2397, - 79, 79, 79, 79, 79, 79, 79, 79, - 79, 79, 79, 79, 79, 2397, 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, 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, 79, 79, 79, 79, - 79, 79, 79, 79, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 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, 77, 77, 77, - 77, 77, 77, 77, 77, 77, 77, 77, - 77, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 79, - 79, 79, 79, 79, 79, 2397, 79, 79, - 79, 2397, 2397, 2397, 79, 79, 2397, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 79, 79, 79, 79, 79, 79, 79, - 79, 79, 79, 79, 2397, 2397, 0, 0, - 0, 79, 79, 79, 79, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 0, 0, 0, 0, - 0, 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, 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, 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, 77, 77, 77, - 77, 77, 77, 77, 77, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 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, 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, 77, 77, 77, 77, 77, 77, 77, - 77, 77, 77, 77, 77, 77, 79, 79, - 79, 79, 0, 0, 0, 0, 0, 0, - 0, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 77, 77, 77, 77, 77, 77, 77, - 77, 77, 77, 77, 77, 0, 0, 0, - 0, 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, 77, 77, 77, - 77, 77, 77, 77, 77, 77, 77, 77, - 77, 77, 77, 77, 77, 77, 77, 77, - 77, 0, 0, 0, 0, 0, 0, 0, - 0, 77, 77, 77, 77, 77, 77, 77, - 77, 77, 77, 0, 0, 0, 0, 0, - 0, 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, 77, 77, 77, - 77, 0, 0, 0, 0, 0, 0, 0, - 0, 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, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 77, 77, 77, 77, 77, 77, 77, - 77, 77, 77, 77, 77, 0, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2815, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2815, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 0, 2397, 2397, 2397, 2397, - 0, 0, 0, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 0, 0, 2397, 2397, - 2397, 2397, 2397, 2397, 0, 0, 0, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 0, 0, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, - 2397, 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, - 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, 79, - 79, 79, 79, 79, 79, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 79, 79, 79, 79, 79, 79, 79, - 79, 79, 79, 79, 79, 79, 79, 0, - 0, 2397, 2397, 2397, 2397, 0, 0, 0, - 0, 2397, 2397, 2397, 0, 0, 0, 0, - 0, 2397, 2397, 2397, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 2397, 2397, 2397, 2397, 2397, 2397, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 0, - 0, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, - 3035, 3035, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 6370, 6371, 6372, 6373, 6374, 4373, 6375, - 6376, 6377, 6378, 4374, 6379, 6380, 6381, 4375, - 6382, 6383, 6384, 6385, 6386, 6387, 6388, 6389, - 6390, 6391, 6392, 6393, 4433, 6394, 6395, 6396, - 6397, 6398, 6399, 6400, 6401, 6402, 4438, 4376, - 4377, 4439, 6403, 6404, 4184, 6405, 4378, 6406, - 6407, 6408, 6409, 6409, 6409, 6410, 6411, 6412, - 6413, 6414, 6415, 6416, 6417, 6418, 6419, 6420, - 6421, 6422, 6423, 6424, 6425, 6426, 6427, 6427, - 4441, 6428, 6429, 6430, 6431, 4380, 6432, 6433, - 6434, 4337, 6435, 6436, 6437, 6438, 6439, 6440, - 6441, 6442, 6443, 6444, 6445, 6446, 6447, 6448, - 6449, 6450, 6451, 6452, 6453, 6454, 6455, 6456, - 6457, 6458, 6459, 6460, 6460, 6461, 6462, 6463, - 4180, 6464, 6465, 6466, 6467, 6468, 6469, 6470, - 6471, 4385, 6472, 6473, 6474, 6475, 6476, 6477, - 6478, 6479, 6480, 6481, 6482, 6483, 6484, 6485, - 6486, 6487, 6488, 6489, 6490, 6491, 6492, 4126, - 6493, 6494, 6495, 6495, 6496, 6497, 6497, 6498, - 6499, 6500, 6501, 6502, 6503, 6504, 6505, 6506, - 6507, 6508, 6509, 6510, 4386, 6511, 6512, 6513, - 6514, 4453, 6514, 6515, 4388, 6516, 6517, 6518, - 6519, 4389, 4099, 6520, 6521, 6522, 6523, 6524, - 6525, 6526, 6527, 6528, 6529, 6530, 6531, 6532, - 6533, 6534, 6535, 6536, 6537, 6538, 6539, 6540, - 6541, 4390, 6542, 6543, 6544, 6545, 6546, 6547, - 4392, 6548, 6549, 6550, 6551, 6552, 6553, 6554, - 6555, 4127, 4461, 6556, 6557, 6558, 6559, 6560, - 6561, 6562, 6563, 4393, 6564, 6565, 6566, 6567, - 4504, 6568, 6569, 6570, 6571, 6572, 6573, 6574, - 6575, 6576, 6577, 6578, 6579, 6580, 4197, 6581, - 6582, 6583, 6584, 6585, 6586, 6587, 6588, 6589, - 6590, 6591, 4394, 4284, 6592, 6593, 6594, 6595, - 6596, 6597, 6598, 6599, 4465, 6600, 6601, 6602, - 6603, 6604, 6605, 6606, 6607, 4466, 6608, 6609, - 6610, 6611, 6612, 6613, 6614, 6615, 6616, 6617, - 6618, 6619, 4468, 6620, 6621, 6622, 6623, 6624, - 6625, 6626, 6627, 6628, 6629, 6630, 6630, 6631, - 6632, 4470, 6633, 6634, 6635, 6636, 6637, 6638, - 6639, 4183, 6640, 6641, 6642, 6643, 6644, 6645, - 6646, 4476, 6647, 6648, 6649, 6650, 6651, 6652, - 6652, 4477, 4506, 6653, 6654, 6655, 6656, 6657, - 4145, 4479, 6658, 6659, 4405, 6660, 6661, 4359, - 6662, 6663, 4409, 6664, 6665, 6666, 6667, 6667, - 6668, 6669, 6670, 6671, 6672, 6673, 6674, 6675, - 6676, 6677, 6678, 6679, 6680, 6681, 6682, 6683, - 6684, 6685, 6686, 6687, 6688, 6689, 6690, 6691, - 6692, 6693, 6694, 4415, 6695, 6696, 6697, 6698, - 6699, 6700, 6701, 6702, 6703, 6704, 6705, 6706, - 6707, 6708, 6709, 6710, 6496, 6711, 6712, 6713, - 6714, 6715, 6716, 6717, 6718, 6719, 6720, 6721, - 6722, 4201, 6723, 6724, 6725, 6726, 6727, 6728, - 4418, 6729, 6730, 6731, 6732, 6733, 6734, 6735, - 6736, 6737, 6738, 6739, 6740, 6741, 6742, 6743, - 6744, 6745, 6746, 6747, 6748, 4140, 6749, 6750, - 6751, 6752, 6753, 6754, 4486, 6755, 6756, 6757, - 6758, 6759, 6760, 6761, 6762, 6763, 6764, 6765, - 6766, 6767, 6768, 6769, 6770, 6771, 6772, 6773, - 6774, 4491, 4492, 6775, 6776, 6777, 6778, 6779, - 6780, 6781, 6782, 6783, 6784, 6785, 6786, 6787, - 4493, 6788, 6789, 6790, 6791, 6792, 6793, 6794, - 6795, 6796, 6797, 6798, 6799, 6800, 6801, 6802, - 6803, 6804, 6805, 6806, 6807, 6808, 6809, 6810, - 6811, 6812, 6813, 6814, 6815, 6816, 6817, 4499, - 4499, 6818, 6819, 6820, 6821, 6822, 6823, 6824, - 6825, 6826, 6827, 4500, 6828, 6829, 6830, 6831, - 6832, 6833, 6834, 6835, 6836, 6837, 6838, 6839, - 6840, 6841, 6842, 6843, 6844, 6845, 6846, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, + 0, 7776, 7777, 7778, 7779, 7780, 4649, 7781, + 7782, 7783, 7784, 4650, 7785, 7786, 7787, 4651, + 7788, 7789, 7790, 7791, 7792, 7793, 7794, 7795, + 7796, 7797, 7798, 7799, 4709, 7800, 7801, 7802, + 7803, 7804, 7805, 7806, 7807, 7808, 4714, 4652, + 4653, 4715, 7809, 7810, 4460, 7811, 4654, 7812, + 7813, 7814, 7815, 7815, 7815, 7816, 7817, 7818, + 7819, 7820, 7821, 7822, 7823, 7824, 7825, 7826, + 7827, 7828, 7829, 7830, 7831, 7832, 7833, 7833, + 4717, 7834, 7835, 7836, 7837, 4656, 7838, 7839, + 7840, 4613, 7841, 7842, 7843, 7844, 7845, 7846, + 7847, 7848, 7849, 7850, 7851, 7852, 7853, 7854, + 7855, 7856, 7857, 7858, 7859, 7860, 7861, 7862, + 7863, 7864, 7865, 7866, 7866, 7867, 7868, 7869, + 4456, 7870, 7871, 7872, 7873, 7874, 7875, 7876, + 7877, 4661, 7878, 7879, 7880, 7881, 7882, 7883, + 7884, 7885, 7886, 7887, 7888, 7889, 7890, 7891, + 7892, 7893, 7894, 7895, 7896, 7897, 7898, 4402, + 7899, 7900, 7901, 7901, 7902, 7903, 7903, 7904, + 7905, 7906, 7907, 7908, 7909, 7910, 7911, 7912, + 7913, 7914, 7915, 7916, 4662, 7917, 7918, 7919, + 7920, 4729, 7920, 7921, 4664, 7922, 7923, 7924, + 7925, 4665, 4375, 7926, 7927, 7928, 7929, 7930, + 7931, 7932, 7933, 7934, 7935, 7936, 7937, 7938, + 7939, 7940, 7941, 7942, 7943, 7944, 7945, 7946, + 7947, 4666, 7948, 7949, 7950, 7951, 7952, 7953, + 4668, 7954, 7955, 7956, 7957, 7958, 7959, 7960, + 7961, 4403, 4737, 7962, 7963, 7964, 7965, 7966, + 7967, 7968, 7969, 4669, 7970, 7971, 7972, 7973, + 4780, 7974, 7975, 7976, 7977, 7978, 7979, 7980, + 7981, 7982, 7983, 7984, 7985, 7986, 4473, 7987, + 7988, 7989, 7990, 7991, 7992, 7993, 7994, 7995, + 7996, 7997, 4670, 4560, 7998, 7999, 8000, 8001, + 8002, 8003, 8004, 8005, 4741, 8006, 8007, 8008, + 8009, 8010, 8011, 8012, 8013, 4742, 8014, 8015, + 8016, 8017, 8018, 8019, 8020, 8021, 8022, 8023, + 8024, 8025, 4744, 8026, 8027, 8028, 8029, 8030, + 8031, 8032, 8033, 8034, 8035, 8036, 8036, 8037, + 8038, 4746, 8039, 8040, 8041, 8042, 8043, 8044, + 8045, 4459, 8046, 8047, 8048, 8049, 8050, 8051, + 8052, 4752, 8053, 8054, 8055, 8056, 8057, 8058, + 8058, 4753, 4782, 8059, 8060, 8061, 8062, 8063, + 4421, 4755, 8064, 8065, 4681, 8066, 8067, 4635, + 8068, 8069, 4685, 8070, 8071, 8072, 8073, 8073, + 8074, 8075, 8076, 8077, 8078, 8079, 8080, 8081, + 8082, 8083, 8084, 8085, 8086, 8087, 8088, 8089, + 8090, 8091, 8092, 8093, 8094, 8095, 8096, 8097, + 8098, 8099, 8100, 4691, 8101, 8102, 8103, 8104, + 8105, 8106, 8107, 8108, 8109, 8110, 8111, 8112, + 8113, 8114, 8115, 8116, 7902, 8117, 8118, 8119, + 8120, 8121, 8122, 8123, 8124, 8125, 8126, 8127, + 8128, 4477, 8129, 8130, 8131, 8132, 8133, 8134, + 4694, 8135, 8136, 8137, 8138, 8139, 8140, 8141, + 8142, 8143, 8144, 8145, 8146, 8147, 8148, 8149, + 8150, 8151, 8152, 8153, 8154, 4416, 8155, 8156, + 8157, 8158, 8159, 8160, 4762, 8161, 8162, 8163, + 8164, 8165, 8166, 8167, 8168, 8169, 8170, 8171, + 8172, 8173, 8174, 8175, 8176, 8177, 8178, 8179, + 8180, 4767, 4768, 8181, 8182, 8183, 8184, 8185, + 8186, 8187, 8188, 8189, 8190, 8191, 8192, 8193, + 4769, 8194, 8195, 8196, 8197, 8198, 8199, 8200, + 8201, 8202, 8203, 8204, 8205, 8206, 8207, 8208, + 8209, 8210, 8211, 8212, 8213, 8214, 8215, 8216, + 8217, 8218, 8219, 8220, 8221, 8222, 8223, 4775, + 4775, 8224, 8225, 8226, 8227, 8228, 8229, 8230, + 8231, 8232, 8233, 4776, 8234, 8235, 8236, 8237, + 8238, 8239, 8240, 8241, 8242, 8243, 8244, 8245, + 8246, 8247, 8248, 8249, 8250, 8251, 8252, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -6906,23 +7572,64 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1459, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 0, 0, 0, 0, + 0, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 3227, 3227, 3227, 3227, 3227, 3227, 3227, + 3227, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 2129, 2129, 2129, 2129, 2129, 2129, 2129, - 2129, 2129, 2129, 2129, 2129, 2129, 2129, 2129, - 2129, 2129, 2129, 2129, 2129, 2129, 2129, 2129, - 2129, 2129, 2129, 2129, 2129, 2129, 2129, 2129, - 2129, 2129, 2129, 2129, 2129, 2129, 2129, 2129, - 2129, 2129, 2129, 2129, 2129, 2129, 2129, 2129, - 2129, 2129, 2129, 2129, 2129, 2129, 2129, 2129, - 2129, 2129, 2129, 2129, 2129, 2129, 2129, 2129, - 2129, 2129, 2129, 2129, 2129, 2129, 2129, 2129, - 2129, 2129, 2129, 2129, 2129, 2129, 2129, 2129, - 2129, 2129, 2129, 2129, 2129, 2129, 2129, 2129, - 2129, 2129, 2129, 2129, 2129, 2129, 2129, 2129, - 2129, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -6931,6927 +7638,8359 @@ static const utf8proc_uint16_t utf8proc_stage2table[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1538, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 8253, 8253, 8253, 8253, 8253, 8253, 8253, + 8253, 8253, 8253, 8253, 8253, 8253, 8253, 8253, + 8253, 8253, 8253, 8253, 8253, 8253, 8253, 8253, + 8253, 8253, 8253, 8253, 8253, 8253, 8253, 8253, + 8253, 8253, 8253, 8253, 8253, 8253, 8253, 8253, + 8253, 8253, 8253, 8253, 8253, 8253, 8253, 8253, + 8253, 8253, 8253, 8253, 8253, 8253, 8253, 8253, + 8253, 8253, 8253, 8253, 8253, 8253, 8253, 8253, + 8253, 8253, 8253, 8253, 8253, 8253, 8253, 8253, + 8253, 8253, 8253, 8253, 8253, 8253, 8253, 8253, + 8253, 8253, 8253, 8253, 8253, 8253, 8253, 8253, + 8253, 8253, 8253, 8253, 8253, 8253, 8253, 8253, + 8253, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 577, 577, 577, 577, 577, 577, 577, - 577, 577, 577, 577, 577, 577, 577, 577, - 577, 577, 577, 577, 577, 577, 577, 577, - 577, 577, 577, 577, 577, 577, 577, 577, - 577, 577, 577, 577, 577, 577, 577, 577, - 577, 577, 577, 577, 577, 577, 577, 577, - 577, 577, 577, 577, 577, 577, 577, 577, - 577, 577, 577, 577, 577, 577, 577, 577, - 577, 577, 577, 577, 577, 577, 577, 577, - 577, 577, 577, 577, 577, 577, 577, 577, - 577, 577, 577, 577, 577, 577, 577, 577, - 577, 577, 577, 577, 577, 577, 577, 577, - 577, 577, 577, 577, 577, 577, 577, 577, - 577, 577, 577, 577, 577, 577, 577, 577, - 577, 577, 577, 577, 577, 577, 577, 577, - 577, 577, 577, 577, 577, 577, 577, 577, - 577, 577, 577, 577, 577, 577, 577, 577, - 577, 577, 577, 577, 577, 577, 577, 577, - 577, 577, 577, 577, 577, 577, 577, 577, - 577, 577, 577, 577, 577, 577, 577, 577, - 577, 577, 577, 577, 577, 577, 577, 577, - 577, 577, 577, 577, 577, 577, 577, 577, - 577, 577, 577, 577, 577, 577, 577, 577, - 577, 577, 577, 577, 577, 577, 577, 577, - 577, 577, 577, 577, 577, 577, 577, 577, - 577, 577, 577, 577, 577, 577, 577, 577, - 577, 577, 577, 577, 577, 577, 577, 577, - 577, 577, 577, 577, 577, 577, 577, 577, - 577, 577, 577, 577, 577, 577, 577, 577, - 577, 577, 577, 577, 577, 577, 577, 577, - 577, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, - 4086, 4086, 4086, 4086, 4086, 4086, 4086, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, + 648, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 4362, + 4362, 4362, 4362, 4362, 4362, 4362, 4362, 0, 0, }; static const utf8proc_property_t utf8proc_properties[] = { - {0, 0, 0, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false,false,false,false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_CC, 0, UTF8PROC_BIDI_CLASS_BN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL}, - {UTF8PROC_CATEGORY_CC, 0, UTF8PROC_BIDI_CLASS_BN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL}, - {UTF8PROC_CATEGORY_CC, 0, UTF8PROC_BIDI_CLASS_S, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL}, - {UTF8PROC_CATEGORY_CC, 0, UTF8PROC_BIDI_CLASS_B, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_LF}, - {UTF8PROC_CATEGORY_CC, 0, UTF8PROC_BIDI_CLASS_WS, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL}, - {UTF8PROC_CATEGORY_CC, 0, UTF8PROC_BIDI_CLASS_B, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CR}, - {UTF8PROC_CATEGORY_CC, 0, UTF8PROC_BIDI_CLASS_B, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL}, - {UTF8PROC_CATEGORY_ZS, 0, UTF8PROC_BIDI_CLASS_WS, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ET, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ES, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5093, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5084, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5096, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 0, UINT16_MAX, 0, UINT16_MAX, 0, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1, UINT16_MAX, 1, UINT16_MAX, 2784, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2, UINT16_MAX, 2, UINT16_MAX, 49, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3, UINT16_MAX, 3, UINT16_MAX, 704, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4, UINT16_MAX, 4, UINT16_MAX, 62, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5, UINT16_MAX, 5, UINT16_MAX, 2872, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6, UINT16_MAX, 6, UINT16_MAX, 782, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7, UINT16_MAX, 7, UINT16_MAX, 808, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8, UINT16_MAX, 8, UINT16_MAX, 111, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9, UINT16_MAX, 9, UINT16_MAX, 898, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 10, UINT16_MAX, 10, UINT16_MAX, 913, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 11, UINT16_MAX, 11, UINT16_MAX, 999, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 12, UINT16_MAX, 12, UINT16_MAX, 2890, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 13, UINT16_MAX, 13, UINT16_MAX, 160, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 14, UINT16_MAX, 14, UINT16_MAX, 205, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 15, UINT16_MAX, 15, UINT16_MAX, 2982, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 16, UINT16_MAX, 16, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 17, UINT16_MAX, 17, UINT16_MAX, 1087, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 18, UINT16_MAX, 18, UINT16_MAX, 1173, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 19, UINT16_MAX, 19, UINT16_MAX, 1257, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 20, UINT16_MAX, 20, UINT16_MAX, 254, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 21, UINT16_MAX, 21, UINT16_MAX, 3042, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 22, UINT16_MAX, 22, UINT16_MAX, 1337, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 23, UINT16_MAX, 23, UINT16_MAX, 3122, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 24, UINT16_MAX, 24, UINT16_MAX, 303, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 25, UINT16_MAX, 25, UINT16_MAX, 1423, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PC, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1491, UINT16_MAX, 1491, 352, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1493, UINT16_MAX, 1493, 2818, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2812, UINT16_MAX, 2812, 401, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1494, UINT16_MAX, 1494, 743, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1495, UINT16_MAX, 1495, 414, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2837, UINT16_MAX, 2837, 2875, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1497, UINT16_MAX, 1497, 795, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1498, UINT16_MAX, 1498, 853, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1499, UINT16_MAX, 1499, 463, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1500, UINT16_MAX, 1500, 901, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1501, UINT16_MAX, 1501, 956, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1502, UINT16_MAX, 1502, 1043, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1503, UINT16_MAX, 1503, 2932, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1504, UINT16_MAX, 1504, 512, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1505, UINT16_MAX, 1505, 557, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1507, UINT16_MAX, 1507, 2994, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2826, UINT16_MAX, 2826, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1508, UINT16_MAX, 1508, 1130, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 3305, UINT16_MAX, 3305, 1215, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1509, UINT16_MAX, 1509, 1296, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1510, UINT16_MAX, 1510, 606, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2908, UINT16_MAX, 2908, 3082, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1511, UINT16_MAX, 1511, 1380, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2925, UINT16_MAX, 2925, 3131, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 3312, UINT16_MAX, 3312, 655, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2834, UINT16_MAX, 2834, 1466, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_ZS, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_NOBREAK, 26, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 8219, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 1621, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PI, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_BN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 1, 0, UTF8PROC_BOUNDCLASS_CONTROL}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 8221, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ET, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ET, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 31, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 32, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 8225, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 35, 35, 7220, UINT16_MAX, 7220, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 8228, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 38, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 14, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PF, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 16423, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 16426, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 16429, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8240, 50, UINT16_MAX, 50, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8243, 53, UINT16_MAX, 53, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8246, 56, UINT16_MAX, 56, UINT16_MAX, 3143, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8249, 59, UINT16_MAX, 59, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8252, 62, UINT16_MAX, 62, UINT16_MAX, 1537, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8255, 65, UINT16_MAX, 65, UINT16_MAX, 1579, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 66, UINT16_MAX, 66, UINT16_MAX, 1549, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8259, 69, UINT16_MAX, 69, UINT16_MAX, 2852, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8262, 72, UINT16_MAX, 72, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8265, 75, UINT16_MAX, 75, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8268, 78, UINT16_MAX, 78, UINT16_MAX, 3357, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8271, 81, UINT16_MAX, 81, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8274, 84, UINT16_MAX, 84, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8277, 87, UINT16_MAX, 87, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8280, 90, UINT16_MAX, 90, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8283, 93, UINT16_MAX, 93, UINT16_MAX, 2878, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 94, UINT16_MAX, 94, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8287, 97, UINT16_MAX, 97, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8290, 100, UINT16_MAX, 100, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8293, 103, UINT16_MAX, 103, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8296, 106, UINT16_MAX, 106, UINT16_MAX, 3461, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8299, 109, UINT16_MAX, 109, UINT16_MAX, 1597, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8302, 112, UINT16_MAX, 112, UINT16_MAX, 1591, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 113, UINT16_MAX, 113, UINT16_MAX, 1585, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8306, 116, UINT16_MAX, 116, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8309, 119, UINT16_MAX, 119, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8312, 122, UINT16_MAX, 122, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8315, 125, UINT16_MAX, 125, UINT16_MAX, 1509, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8318, 128, UINT16_MAX, 128, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 129, UINT16_MAX, 129, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8322, 8069, UINT16_MAX, 8069, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8324, UINT16_MAX, 8070, UINT16_MAX, 8070, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8326, UINT16_MAX, 8071, UINT16_MAX, 8071, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8328, UINT16_MAX, 8072, UINT16_MAX, 8072, 3192, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8330, UINT16_MAX, 8073, UINT16_MAX, 8073, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8332, UINT16_MAX, 8074, UINT16_MAX, 8074, 1540, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8334, UINT16_MAX, 2836, UINT16_MAX, 2836, 1582, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1492, UINT16_MAX, 1492, 1558, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8336, UINT16_MAX, 8075, UINT16_MAX, 8075, 2855, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8338, UINT16_MAX, 8076, UINT16_MAX, 8076, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8340, UINT16_MAX, 8077, UINT16_MAX, 8077, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8342, UINT16_MAX, 8078, UINT16_MAX, 8078, 3406, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8344, UINT16_MAX, 8079, UINT16_MAX, 8079, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8346, UINT16_MAX, 8080, UINT16_MAX, 8080, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8348, UINT16_MAX, 8081, UINT16_MAX, 8081, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8350, UINT16_MAX, 8082, UINT16_MAX, 8082, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8352, UINT16_MAX, 8083, UINT16_MAX, 8083, 2881, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8084, UINT16_MAX, 8084, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8354, UINT16_MAX, 8085, UINT16_MAX, 8085, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8356, UINT16_MAX, 8086, UINT16_MAX, 8086, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8358, UINT16_MAX, 8087, UINT16_MAX, 8087, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8360, UINT16_MAX, 8088, UINT16_MAX, 8088, 3510, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8362, UINT16_MAX, 8089, UINT16_MAX, 8089, 1606, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8364, UINT16_MAX, 8090, UINT16_MAX, 8090, 1594, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8091, UINT16_MAX, 8091, 1588, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8366, UINT16_MAX, 8092, UINT16_MAX, 8092, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8368, UINT16_MAX, 8093, UINT16_MAX, 8093, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8370, UINT16_MAX, 8094, UINT16_MAX, 8094, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8372, UINT16_MAX, 8095, UINT16_MAX, 8095, 1523, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8374, UINT16_MAX, 8096, UINT16_MAX, 8096, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8097, UINT16_MAX, 8097, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8376, UINT16_MAX, 8098, UINT16_MAX, 8098, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8378, 188, UINT16_MAX, 188, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8381, UINT16_MAX, 8099, UINT16_MAX, 8099, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8383, 193, UINT16_MAX, 193, UINT16_MAX, 3259, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8386, UINT16_MAX, 8100, UINT16_MAX, 8100, 3308, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8388, 198, UINT16_MAX, 198, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8391, UINT16_MAX, 8101, UINT16_MAX, 8101, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8393, 203, UINT16_MAX, 203, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8396, UINT16_MAX, 8102, UINT16_MAX, 8102, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8398, 208, UINT16_MAX, 208, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8401, UINT16_MAX, 8103, UINT16_MAX, 8103, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8403, 213, UINT16_MAX, 213, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8406, UINT16_MAX, 8104, UINT16_MAX, 8104, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8408, 218, UINT16_MAX, 218, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8411, UINT16_MAX, 8105, UINT16_MAX, 8105, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8413, 223, UINT16_MAX, 223, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8416, UINT16_MAX, 8106, UINT16_MAX, 8106, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 226, UINT16_MAX, 226, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8107, UINT16_MAX, 8107, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8419, 229, UINT16_MAX, 229, UINT16_MAX, 2858, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8422, UINT16_MAX, 8108, UINT16_MAX, 8108, 2862, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8424, 234, UINT16_MAX, 234, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8427, UINT16_MAX, 8109, UINT16_MAX, 8109, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8429, 239, UINT16_MAX, 239, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8432, UINT16_MAX, 8110, UINT16_MAX, 8110, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8434, 244, UINT16_MAX, 244, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8437, UINT16_MAX, 8111, UINT16_MAX, 8111, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8439, 249, UINT16_MAX, 249, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8442, UINT16_MAX, 8112, UINT16_MAX, 8112, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8444, 254, UINT16_MAX, 254, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8447, UINT16_MAX, 8113, UINT16_MAX, 8113, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8449, 259, UINT16_MAX, 259, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8452, UINT16_MAX, 8114, UINT16_MAX, 8114, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8454, 264, UINT16_MAX, 264, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8457, UINT16_MAX, 8115, UINT16_MAX, 8115, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8459, 269, UINT16_MAX, 269, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8462, UINT16_MAX, 8116, UINT16_MAX, 8116, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8464, 274, UINT16_MAX, 274, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8467, UINT16_MAX, 8117, UINT16_MAX, 8117, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 277, UINT16_MAX, 277, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 5164, UINT16_MAX, 5164, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8470, 280, UINT16_MAX, 280, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8473, UINT16_MAX, 8118, UINT16_MAX, 8118, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8475, 285, UINT16_MAX, 285, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8478, UINT16_MAX, 8119, UINT16_MAX, 8119, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8480, 290, UINT16_MAX, 290, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8483, UINT16_MAX, 8120, UINT16_MAX, 8120, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8485, 295, UINT16_MAX, 295, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8488, UINT16_MAX, 8121, UINT16_MAX, 8121, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8490, 8492, UINT16_MAX, 8, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1499, UINT16_MAX, 1499, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8494, 304, UINT16_MAX, 304, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8497, UINT16_MAX, 8122, UINT16_MAX, 8122, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8499, 309, UINT16_MAX, 309, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8502, UINT16_MAX, 8123, UINT16_MAX, 8123, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8504, 314, UINT16_MAX, 314, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8507, UINT16_MAX, 8124, UINT16_MAX, 8124, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8509, 319, UINT16_MAX, 319, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8512, UINT16_MAX, 8125, UINT16_MAX, 8125, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8514, 324, UINT16_MAX, 324, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8517, UINT16_MAX, 8126, UINT16_MAX, 8126, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8519, 329, UINT16_MAX, 329, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8522, UINT16_MAX, 8127, UINT16_MAX, 8127, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8524, 334, UINT16_MAX, 334, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8527, UINT16_MAX, 8128, UINT16_MAX, 8128, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 337, UINT16_MAX, 337, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8129, UINT16_MAX, 8129, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8530, 340, UINT16_MAX, 340, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8533, UINT16_MAX, 8130, UINT16_MAX, 8130, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8535, 345, UINT16_MAX, 345, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8538, UINT16_MAX, 8131, UINT16_MAX, 8131, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8540, 350, UINT16_MAX, 350, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8543, UINT16_MAX, 8132, UINT16_MAX, 8132, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8545, 8545, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 355, UINT16_MAX, 355, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8133, UINT16_MAX, 8133, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8548, 358, UINT16_MAX, 358, UINT16_MAX, 2974, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8551, UINT16_MAX, 8134, UINT16_MAX, 8134, 2978, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8553, 363, UINT16_MAX, 363, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8556, UINT16_MAX, 8135, UINT16_MAX, 8135, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8558, 368, UINT16_MAX, 368, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8561, UINT16_MAX, 8136, UINT16_MAX, 8136, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 371, UINT16_MAX, 371, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8137, UINT16_MAX, 8137, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8564, 374, UINT16_MAX, 374, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8567, UINT16_MAX, 8138, UINT16_MAX, 8138, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8569, 379, UINT16_MAX, 379, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8572, UINT16_MAX, 8139, UINT16_MAX, 8139, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8574, 384, UINT16_MAX, 384, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8577, UINT16_MAX, 8140, UINT16_MAX, 8140, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8579, 389, UINT16_MAX, 389, UINT16_MAX, 3012, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8582, UINT16_MAX, 8141, UINT16_MAX, 8141, 3015, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8584, 394, UINT16_MAX, 394, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8587, UINT16_MAX, 8142, UINT16_MAX, 8142, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8589, 399, UINT16_MAX, 399, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8592, UINT16_MAX, 8143, UINT16_MAX, 8143, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8594, 404, UINT16_MAX, 404, UINT16_MAX, 3018, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8597, UINT16_MAX, 8144, UINT16_MAX, 8144, 3021, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8599, 409, UINT16_MAX, 409, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8602, UINT16_MAX, 8145, UINT16_MAX, 8145, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8604, 414, UINT16_MAX, 414, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8607, UINT16_MAX, 8146, UINT16_MAX, 8146, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 417, UINT16_MAX, 417, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8147, UINT16_MAX, 8147, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8610, 420, UINT16_MAX, 420, UINT16_MAX, 3030, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8613, UINT16_MAX, 8148, UINT16_MAX, 8148, 3033, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8615, 425, UINT16_MAX, 425, UINT16_MAX, 3036, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8618, UINT16_MAX, 8149, UINT16_MAX, 8149, 3039, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8620, 430, UINT16_MAX, 430, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8623, UINT16_MAX, 8150, UINT16_MAX, 8150, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8625, 435, UINT16_MAX, 435, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8628, UINT16_MAX, 8151, UINT16_MAX, 8151, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8630, 440, UINT16_MAX, 440, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8633, UINT16_MAX, 8152, UINT16_MAX, 8152, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8635, 445, UINT16_MAX, 445, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8638, UINT16_MAX, 8153, UINT16_MAX, 8153, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8640, 450, UINT16_MAX, 450, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8643, UINT16_MAX, 8154, UINT16_MAX, 8154, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8645, 455, UINT16_MAX, 455, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8648, UINT16_MAX, 8155, UINT16_MAX, 8155, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8650, 460, UINT16_MAX, 460, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8653, 463, UINT16_MAX, 463, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8656, UINT16_MAX, 8156, UINT16_MAX, 8156, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8658, 468, UINT16_MAX, 468, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8661, UINT16_MAX, 8157, UINT16_MAX, 8157, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8663, 473, UINT16_MAX, 473, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8666, UINT16_MAX, 8158, UINT16_MAX, 8158, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 18, 18, 3305, UINT16_MAX, 3305, 3140, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8159, UINT16_MAX, 8159, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 476, UINT16_MAX, 476, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 477, UINT16_MAX, 477, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8160, UINT16_MAX, 8160, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 478, UINT16_MAX, 478, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8161, UINT16_MAX, 8161, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 479, UINT16_MAX, 479, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 480, UINT16_MAX, 480, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8162, UINT16_MAX, 8162, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 481, UINT16_MAX, 481, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 482, UINT16_MAX, 482, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 483, UINT16_MAX, 483, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8163, UINT16_MAX, 8163, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 484, UINT16_MAX, 484, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 485, UINT16_MAX, 485, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 486, UINT16_MAX, 486, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 487, UINT16_MAX, 487, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8164, UINT16_MAX, 8164, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 488, UINT16_MAX, 488, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 489, UINT16_MAX, 489, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8165, UINT16_MAX, 8165, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 490, UINT16_MAX, 490, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 491, UINT16_MAX, 491, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 492, UINT16_MAX, 492, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8166, UINT16_MAX, 8166, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8167, UINT16_MAX, 8167, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 493, UINT16_MAX, 493, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 494, UINT16_MAX, 494, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8168, UINT16_MAX, 8168, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 495, UINT16_MAX, 495, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8688, 498, UINT16_MAX, 498, UINT16_MAX, 3565, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8691, UINT16_MAX, 8169, UINT16_MAX, 8169, 3614, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 501, UINT16_MAX, 501, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8170, UINT16_MAX, 8170, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 502, UINT16_MAX, 502, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8171, UINT16_MAX, 8171, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 503, UINT16_MAX, 503, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 504, UINT16_MAX, 504, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8172, UINT16_MAX, 8172, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 505, UINT16_MAX, 505, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 506, UINT16_MAX, 506, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8173, UINT16_MAX, 8173, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 507, UINT16_MAX, 507, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8700, 510, UINT16_MAX, 510, UINT16_MAX, 3663, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8703, UINT16_MAX, 8174, UINT16_MAX, 8174, 3712, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 513, UINT16_MAX, 513, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 514, UINT16_MAX, 514, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 515, UINT16_MAX, 515, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8175, UINT16_MAX, 8175, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 516, UINT16_MAX, 516, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8176, UINT16_MAX, 8176, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 517, UINT16_MAX, 517, UINT16_MAX, 1573, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 518, UINT16_MAX, 518, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8177, UINT16_MAX, 8177, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 519, UINT16_MAX, 519, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8178, UINT16_MAX, 8178, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8179, UINT16_MAX, 8179, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8712, 522, UINT16_MAX, 522, 8180, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8715, 522, 8181, 522, 8180, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8717, UINT16_MAX, 8181, UINT16_MAX, 8180, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8719, 529, UINT16_MAX, 529, 8182, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8722, 529, 8183, 529, 8182, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8724, UINT16_MAX, 8183, UINT16_MAX, 8182, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8726, 536, UINT16_MAX, 536, 8184, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8729, 536, 8185, 536, 8184, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8731, UINT16_MAX, 8185, UINT16_MAX, 8184, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8733, 543, UINT16_MAX, 543, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8736, UINT16_MAX, 8186, UINT16_MAX, 8186, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8738, 548, UINT16_MAX, 548, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8741, UINT16_MAX, 8187, UINT16_MAX, 8187, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8743, 553, UINT16_MAX, 553, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8746, UINT16_MAX, 8188, UINT16_MAX, 8188, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8748, 558, UINT16_MAX, 558, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8751, UINT16_MAX, 8189, UINT16_MAX, 8189, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8753, 563, UINT16_MAX, 563, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8756, UINT16_MAX, 8190, UINT16_MAX, 8190, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8758, 568, UINT16_MAX, 568, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8761, UINT16_MAX, 8191, UINT16_MAX, 8191, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8763, 573, UINT16_MAX, 573, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8766, UINT16_MAX, 8192, UINT16_MAX, 8192, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8768, 578, UINT16_MAX, 578, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8771, UINT16_MAX, 8193, UINT16_MAX, 8193, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1496, UINT16_MAX, 1496, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8773, 583, UINT16_MAX, 583, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8776, UINT16_MAX, 8194, UINT16_MAX, 8194, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8778, 588, UINT16_MAX, 588, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8781, UINT16_MAX, 8195, UINT16_MAX, 8195, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8783, 593, UINT16_MAX, 593, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8786, UINT16_MAX, 8196, UINT16_MAX, 8196, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 596, UINT16_MAX, 596, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8197, UINT16_MAX, 8197, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8789, 599, UINT16_MAX, 599, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8792, UINT16_MAX, 8198, UINT16_MAX, 8198, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8794, 604, UINT16_MAX, 604, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8797, UINT16_MAX, 8199, UINT16_MAX, 8199, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8799, 609, UINT16_MAX, 609, UINT16_MAX, 1567, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8802, UINT16_MAX, 8200, UINT16_MAX, 8200, 1570, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8804, 614, UINT16_MAX, 614, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8807, UINT16_MAX, 8201, UINT16_MAX, 8201, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8809, 619, UINT16_MAX, 619, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8812, UINT16_MAX, 8202, UINT16_MAX, 8202, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8814, 8814, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8816, 626, UINT16_MAX, 626, 8203, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8819, 626, 8204, 626, 8203, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8821, UINT16_MAX, 8204, UINT16_MAX, 8203, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8823, 633, UINT16_MAX, 633, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8826, UINT16_MAX, 8205, UINT16_MAX, 8205, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 636, UINT16_MAX, 636, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 637, UINT16_MAX, 637, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8830, 640, UINT16_MAX, 640, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8833, UINT16_MAX, 8206, UINT16_MAX, 8206, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8835, 645, UINT16_MAX, 645, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8838, UINT16_MAX, 8207, UINT16_MAX, 8207, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8840, 650, UINT16_MAX, 650, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8843, UINT16_MAX, 8208, UINT16_MAX, 8208, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8845, 655, UINT16_MAX, 655, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8848, UINT16_MAX, 8209, UINT16_MAX, 8209, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8850, 660, UINT16_MAX, 660, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8853, UINT16_MAX, 8210, UINT16_MAX, 8210, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8855, 665, UINT16_MAX, 665, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8858, UINT16_MAX, 8211, UINT16_MAX, 8211, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8860, 670, UINT16_MAX, 670, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8863, UINT16_MAX, 8212, UINT16_MAX, 8212, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8865, 675, UINT16_MAX, 675, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8868, UINT16_MAX, 8213, UINT16_MAX, 8213, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8870, 680, UINT16_MAX, 680, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8873, UINT16_MAX, 8214, UINT16_MAX, 8214, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8875, 685, UINT16_MAX, 685, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8878, UINT16_MAX, 8215, UINT16_MAX, 8215, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8880, 690, UINT16_MAX, 690, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8883, UINT16_MAX, 8216, UINT16_MAX, 8216, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8885, 695, UINT16_MAX, 695, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8888, UINT16_MAX, 8217, UINT16_MAX, 8217, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8890, 700, UINT16_MAX, 700, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8893, UINT16_MAX, 8218, UINT16_MAX, 8218, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8895, 705, UINT16_MAX, 705, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8898, UINT16_MAX, 8219, UINT16_MAX, 8219, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8900, 710, UINT16_MAX, 710, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8903, UINT16_MAX, 8220, UINT16_MAX, 8220, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8905, 715, UINT16_MAX, 715, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8908, UINT16_MAX, 8221, UINT16_MAX, 8221, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8910, 720, UINT16_MAX, 720, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8913, UINT16_MAX, 8222, UINT16_MAX, 8222, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8915, 725, UINT16_MAX, 725, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8918, UINT16_MAX, 8223, UINT16_MAX, 8223, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 728, UINT16_MAX, 728, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8224, UINT16_MAX, 8224, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8921, 731, UINT16_MAX, 731, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8924, UINT16_MAX, 8225, UINT16_MAX, 8225, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 734, UINT16_MAX, 734, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 735, UINT16_MAX, 735, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1506, UINT16_MAX, 1506, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 736, UINT16_MAX, 736, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8226, UINT16_MAX, 8226, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8929, 739, UINT16_MAX, 739, UINT16_MAX, 1543, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8932, UINT16_MAX, 8227, UINT16_MAX, 8227, 1546, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8934, 744, UINT16_MAX, 744, UINT16_MAX, 2866, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8937, UINT16_MAX, 8228, UINT16_MAX, 8228, 2869, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8939, 749, UINT16_MAX, 749, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8942, UINT16_MAX, 8229, UINT16_MAX, 8229, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8944, 754, UINT16_MAX, 754, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8947, UINT16_MAX, 8230, UINT16_MAX, 8230, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8949, 759, UINT16_MAX, 759, UINT16_MAX, 1615, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8952, UINT16_MAX, 8231, UINT16_MAX, 8231, 1618, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8954, 764, UINT16_MAX, 764, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8957, UINT16_MAX, 8232, UINT16_MAX, 8232, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8959, 769, UINT16_MAX, 769, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8962, UINT16_MAX, 8233, UINT16_MAX, 8233, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 772, UINT16_MAX, 772, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 773, UINT16_MAX, 773, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8234, UINT16_MAX, 8234, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 774, UINT16_MAX, 774, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 775, UINT16_MAX, 775, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8235, UINT16_MAX, 8235, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8236, UINT16_MAX, 8236, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 776, UINT16_MAX, 776, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8237, UINT16_MAX, 8237, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 777, UINT16_MAX, 777, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 778, UINT16_MAX, 778, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 779, UINT16_MAX, 779, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 780, UINT16_MAX, 780, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8238, UINT16_MAX, 8238, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 781, UINT16_MAX, 781, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8239, UINT16_MAX, 8239, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 782, UINT16_MAX, 782, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8240, UINT16_MAX, 8240, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 783, UINT16_MAX, 783, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8241, UINT16_MAX, 8241, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 784, UINT16_MAX, 784, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8242, UINT16_MAX, 8242, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8243, UINT16_MAX, 8243, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8244, UINT16_MAX, 8244, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8245, UINT16_MAX, 8245, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8246, UINT16_MAX, 8246, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8247, UINT16_MAX, 8247, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8248, UINT16_MAX, 8248, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8249, UINT16_MAX, 8249, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8250, UINT16_MAX, 8250, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2821, UINT16_MAX, 2821, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8251, UINT16_MAX, 8251, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8252, UINT16_MAX, 8252, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8253, UINT16_MAX, 8253, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8254, UINT16_MAX, 8254, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8255, UINT16_MAX, 8255, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8256, UINT16_MAX, 8256, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8257, UINT16_MAX, 8257, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8258, UINT16_MAX, 8258, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8259, UINT16_MAX, 8259, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8260, UINT16_MAX, 8260, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8261, UINT16_MAX, 8261, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8262, UINT16_MAX, 8262, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8263, UINT16_MAX, 8263, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8264, UINT16_MAX, 8264, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8265, UINT16_MAX, 8265, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8266, UINT16_MAX, 8266, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8267, UINT16_MAX, 8267, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8268, UINT16_MAX, 8268, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8269, UINT16_MAX, 8269, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8270, UINT16_MAX, 8270, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8271, UINT16_MAX, 8271, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8272, UINT16_MAX, 8272, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8273, UINT16_MAX, 8273, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8274, UINT16_MAX, 8274, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8275, UINT16_MAX, 8275, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8276, UINT16_MAX, 8276, 1576, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8277, UINT16_MAX, 8277, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8278, UINT16_MAX, 8278, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 7, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 785, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 9, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 17, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 786, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 787, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 788, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 22, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 24, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 8981, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 8983, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 8985, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 8987, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 8989, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 8991, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 489, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 11, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 18, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 23, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32768, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32769, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32770, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32771, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32775, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32776, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32778, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32772, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32814, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32773, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32780, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32779, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32782, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32783, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32815, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32816, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 232, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 216, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32781, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 202, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32808, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32813, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32807, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32784, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 202, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32774, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 202, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32777, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32810, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32812, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32811, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32809, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 1, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 1, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32819, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, 802, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, 803, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32817, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, 804, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, 8997, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 240, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, 807, 7217, UINT16_MAX, 7217, 32818, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 233, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 234, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 808, UINT16_MAX, 808, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8279, UINT16_MAX, 8279, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 809, UINT16_MAX, 809, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8280, UINT16_MAX, 8280, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 810, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 811, UINT16_MAX, 811, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8281, UINT16_MAX, 8281, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 9004, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8282, UINT16_MAX, 8282, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8283, UINT16_MAX, 8283, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8284, UINT16_MAX, 8284, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, 0, 814, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 815, UINT16_MAX, 815, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 9008, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9010, 820, UINT16_MAX, 820, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, 0, 821, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9014, 824, UINT16_MAX, 824, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9017, 827, UINT16_MAX, 827, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9020, 830, UINT16_MAX, 830, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9023, 833, UINT16_MAX, 833, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9026, 836, UINT16_MAX, 836, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9029, 839, UINT16_MAX, 839, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9032, 17226, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 845, UINT16_MAX, 845, UINT16_MAX, 1673, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 846, UINT16_MAX, 846, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 847, UINT16_MAX, 847, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 848, UINT16_MAX, 848, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 849, UINT16_MAX, 849, UINT16_MAX, 1726, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 850, UINT16_MAX, 850, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 851, UINT16_MAX, 851, UINT16_MAX, 1777, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 852, UINT16_MAX, 852, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 807, UINT16_MAX, 807, UINT16_MAX, 1830, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 853, UINT16_MAX, 853, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 854, UINT16_MAX, 854, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 35, UINT16_MAX, 35, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 855, UINT16_MAX, 855, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 856, UINT16_MAX, 856, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 857, UINT16_MAX, 857, UINT16_MAX, 1881, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 858, UINT16_MAX, 858, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 859, UINT16_MAX, 859, UINT16_MAX, 5027, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 860, UINT16_MAX, 860, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 861, UINT16_MAX, 861, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 862, UINT16_MAX, 862, UINT16_MAX, 1932, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 863, UINT16_MAX, 863, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 864, UINT16_MAX, 864, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 865, UINT16_MAX, 865, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 866, UINT16_MAX, 866, UINT16_MAX, 1983, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9059, 869, UINT16_MAX, 869, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9062, 872, UINT16_MAX, 872, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9065, UINT16_MAX, 2603, UINT16_MAX, 2603, 4904, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9067, UINT16_MAX, 2635, UINT16_MAX, 2635, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9069, UINT16_MAX, 2640, UINT16_MAX, 2640, 4913, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9071, UINT16_MAX, 2676, UINT16_MAX, 2676, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9073, 17267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7211, UINT16_MAX, 7211, 2088, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7212, UINT16_MAX, 7212, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2846, UINT16_MAX, 2846, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7213, UINT16_MAX, 7213, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7214, UINT16_MAX, 7214, 2141, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7215, UINT16_MAX, 7215, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7216, UINT16_MAX, 7216, 2192, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 915, UINT16_MAX, 915, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7217, UINT16_MAX, 7217, 2245, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7218, UINT16_MAX, 7218, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7219, UINT16_MAX, 7219, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7220, UINT16_MAX, 7220, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7221, UINT16_MAX, 7221, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7222, UINT16_MAX, 7222, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7223, UINT16_MAX, 7223, 2401, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2847, UINT16_MAX, 2847, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7224, UINT16_MAX, 7224, 5023, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 860, 917, UINT16_MAX, 917, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 917, UINT16_MAX, 917, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7226, UINT16_MAX, 7226, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 897, UINT16_MAX, 897, 2349, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7227, UINT16_MAX, 7227, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7228, UINT16_MAX, 7228, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7229, UINT16_MAX, 7229, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2835, UINT16_MAX, 2835, 2452, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9078, UINT16_MAX, 8285, UINT16_MAX, 8285, 2036, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9080, UINT16_MAX, 8286, UINT16_MAX, 8286, 2297, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9082, UINT16_MAX, 2745, UINT16_MAX, 2745, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9084, UINT16_MAX, 2714, UINT16_MAX, 2714, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9086, UINT16_MAX, 2750, UINT16_MAX, 2750, 5033, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 896, UINT16_MAX, 896, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 846, 846, 7212, UINT16_MAX, 7212, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 852, 852, 915, UINT16_MAX, 915, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 897, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2505, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9090, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9092, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 863, 863, 7227, UINT16_MAX, 7227, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 858, 858, 2847, UINT16_MAX, 2847, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8287, UINT16_MAX, 8287, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 902, UINT16_MAX, 902, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8288, UINT16_MAX, 8288, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 903, UINT16_MAX, 903, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8289, UINT16_MAX, 8289, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 904, UINT16_MAX, 904, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7238, UINT16_MAX, 7238, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 905, UINT16_MAX, 905, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8290, UINT16_MAX, 8290, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 906, UINT16_MAX, 906, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8291, UINT16_MAX, 8291, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 907, UINT16_MAX, 907, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8292, UINT16_MAX, 8292, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 908, UINT16_MAX, 908, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8293, UINT16_MAX, 8293, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 909, UINT16_MAX, 909, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8294, UINT16_MAX, 8294, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 910, UINT16_MAX, 910, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8295, UINT16_MAX, 8295, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 911, UINT16_MAX, 911, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8296, UINT16_MAX, 8296, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 912, UINT16_MAX, 912, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8297, UINT16_MAX, 8297, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 913, UINT16_MAX, 913, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8298, UINT16_MAX, 8298, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 853, 853, 7218, UINT16_MAX, 7218, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 859, 859, 7224, UINT16_MAX, 7224, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 914, UINT16_MAX, 8299, UINT16_MAX, 8299, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8300, UINT16_MAX, 8300, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 915, 852, UINT16_MAX, 852, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 849, 849, 7214, UINT16_MAX, 7214, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 916, UINT16_MAX, 916, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8301, UINT16_MAX, 8301, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 917, 918, UINT16_MAX, 918, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 919, UINT16_MAX, 919, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8302, UINT16_MAX, 8302, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 920, UINT16_MAX, 920, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 921, UINT16_MAX, 921, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 922, UINT16_MAX, 922, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9115, 925, UINT16_MAX, 925, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9118, 928, UINT16_MAX, 928, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 929, UINT16_MAX, 929, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9122, 932, UINT16_MAX, 932, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 933, UINT16_MAX, 933, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 934, UINT16_MAX, 934, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 935, UINT16_MAX, 935, UINT16_MAX, 2525, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9128, 938, UINT16_MAX, 938, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 939, UINT16_MAX, 939, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 940, UINT16_MAX, 940, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 941, UINT16_MAX, 941, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 942, UINT16_MAX, 942, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9135, 945, UINT16_MAX, 945, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9138, 948, UINT16_MAX, 948, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9141, 951, UINT16_MAX, 951, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 952, UINT16_MAX, 952, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 953, UINT16_MAX, 953, UINT16_MAX, 2615, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 954, UINT16_MAX, 954, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 955, UINT16_MAX, 955, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 956, UINT16_MAX, 956, UINT16_MAX, 2522, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 957, UINT16_MAX, 957, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 958, UINT16_MAX, 958, UINT16_MAX, 2511, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 959, UINT16_MAX, 959, UINT16_MAX, 2601, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 960, UINT16_MAX, 960, UINT16_MAX, 2635, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 961, UINT16_MAX, 961, UINT16_MAX, 2531, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9154, 964, UINT16_MAX, 964, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 965, UINT16_MAX, 965, UINT16_MAX, 2528, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 966, UINT16_MAX, 966, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 967, UINT16_MAX, 967, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 968, UINT16_MAX, 968, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 969, UINT16_MAX, 969, UINT16_MAX, 2641, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 970, UINT16_MAX, 970, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 971, UINT16_MAX, 971, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 972, UINT16_MAX, 972, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 973, UINT16_MAX, 973, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 974, UINT16_MAX, 974, UINT16_MAX, 2542, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 975, UINT16_MAX, 975, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 976, UINT16_MAX, 976, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 977, UINT16_MAX, 977, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 978, UINT16_MAX, 978, UINT16_MAX, 2659, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 979, UINT16_MAX, 979, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 980, UINT16_MAX, 980, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 981, UINT16_MAX, 981, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 982, UINT16_MAX, 982, UINT16_MAX, 2665, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 983, UINT16_MAX, 983, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 984, UINT16_MAX, 984, UINT16_MAX, 2653, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 985, UINT16_MAX, 985, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 986, UINT16_MAX, 986, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8303, UINT16_MAX, 8303, 2622, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8304, UINT16_MAX, 8304, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8305, UINT16_MAX, 8305, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8306, UINT16_MAX, 8306, 2575, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8307, UINT16_MAX, 8307, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8308, UINT16_MAX, 8308, 2564, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8309, UINT16_MAX, 8309, 2608, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8310, UINT16_MAX, 8310, 2638, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8311, UINT16_MAX, 8311, 2553, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9179, UINT16_MAX, 8312, UINT16_MAX, 8312, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8313, UINT16_MAX, 8313, 2581, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8314, UINT16_MAX, 8314, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8315, UINT16_MAX, 8315, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8316, UINT16_MAX, 8316, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8317, UINT16_MAX, 8317, 2644, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8318, UINT16_MAX, 8318, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8319, UINT16_MAX, 8319, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8320, UINT16_MAX, 8320, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8321, UINT16_MAX, 8321, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8322, UINT16_MAX, 8322, 2584, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8323, UINT16_MAX, 8323, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8324, UINT16_MAX, 8324, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8325, UINT16_MAX, 8325, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8326, UINT16_MAX, 8326, 2662, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8327, UINT16_MAX, 8327, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8328, UINT16_MAX, 8328, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8329, UINT16_MAX, 8329, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8330, UINT16_MAX, 8330, 2668, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8331, UINT16_MAX, 8331, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8332, UINT16_MAX, 8332, 2656, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8333, UINT16_MAX, 8333, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8334, UINT16_MAX, 8334, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9181, UINT16_MAX, 8335, UINT16_MAX, 8335, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9183, UINT16_MAX, 8336, UINT16_MAX, 8336, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8337, UINT16_MAX, 8337, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9185, UINT16_MAX, 8338, UINT16_MAX, 8338, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8339, UINT16_MAX, 8339, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8340, UINT16_MAX, 8340, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8341, UINT16_MAX, 8341, 2578, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9187, UINT16_MAX, 8342, UINT16_MAX, 8342, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8343, UINT16_MAX, 8343, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8344, UINT16_MAX, 8344, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8345, UINT16_MAX, 8345, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8346, UINT16_MAX, 8346, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9189, UINT16_MAX, 8347, UINT16_MAX, 8347, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9191, UINT16_MAX, 8348, UINT16_MAX, 8348, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9193, UINT16_MAX, 8349, UINT16_MAX, 8349, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8350, UINT16_MAX, 8350, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1003, UINT16_MAX, 1003, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8351, UINT16_MAX, 8351, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1004, UINT16_MAX, 1004, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8352, UINT16_MAX, 8352, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1005, UINT16_MAX, 1005, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8353, UINT16_MAX, 8353, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1006, UINT16_MAX, 1006, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8354, UINT16_MAX, 8354, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1007, UINT16_MAX, 1007, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8355, UINT16_MAX, 8355, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1008, UINT16_MAX, 1008, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8356, UINT16_MAX, 8356, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1009, UINT16_MAX, 1009, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8357, UINT16_MAX, 8357, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1010, UINT16_MAX, 1010, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8358, UINT16_MAX, 8358, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1011, UINT16_MAX, 1011, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8359, UINT16_MAX, 8359, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1012, UINT16_MAX, 1012, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8360, UINT16_MAX, 8360, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1013, UINT16_MAX, 1013, UINT16_MAX, 2595, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8361, UINT16_MAX, 8361, 2598, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9206, 1016, UINT16_MAX, 1016, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9209, UINT16_MAX, 8362, UINT16_MAX, 8362, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1019, UINT16_MAX, 1019, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8363, UINT16_MAX, 8363, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1020, UINT16_MAX, 1020, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8364, UINT16_MAX, 8364, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1021, UINT16_MAX, 1021, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8365, UINT16_MAX, 8365, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1022, UINT16_MAX, 1022, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8366, UINT16_MAX, 8366, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1023, UINT16_MAX, 1023, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8367, UINT16_MAX, 8367, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_ME, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1024, UINT16_MAX, 1024, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8368, UINT16_MAX, 8368, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1025, UINT16_MAX, 1025, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8369, UINT16_MAX, 8369, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1026, UINT16_MAX, 1026, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8370, UINT16_MAX, 8370, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1027, UINT16_MAX, 1027, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8371, UINT16_MAX, 8371, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1028, UINT16_MAX, 1028, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8372, UINT16_MAX, 8372, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1029, UINT16_MAX, 1029, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8373, UINT16_MAX, 8373, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1030, UINT16_MAX, 1030, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8374, UINT16_MAX, 8374, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1031, UINT16_MAX, 1031, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8375, UINT16_MAX, 8375, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1032, UINT16_MAX, 1032, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8376, UINT16_MAX, 8376, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1033, UINT16_MAX, 1033, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8377, UINT16_MAX, 8377, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1034, UINT16_MAX, 1034, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8378, UINT16_MAX, 8378, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1035, UINT16_MAX, 1035, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8379, UINT16_MAX, 8379, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1036, UINT16_MAX, 1036, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8380, UINT16_MAX, 8380, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1037, UINT16_MAX, 1037, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8381, UINT16_MAX, 8381, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1038, UINT16_MAX, 1038, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8382, UINT16_MAX, 8382, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1039, UINT16_MAX, 1039, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8383, UINT16_MAX, 8383, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1040, UINT16_MAX, 1040, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8384, UINT16_MAX, 8384, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1041, UINT16_MAX, 1041, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8385, UINT16_MAX, 8385, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1042, UINT16_MAX, 1042, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8386, UINT16_MAX, 8386, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1043, UINT16_MAX, 1043, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8387, UINT16_MAX, 8387, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1044, UINT16_MAX, 1044, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8388, UINT16_MAX, 8388, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1045, UINT16_MAX, 1045, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8389, UINT16_MAX, 8389, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1046, UINT16_MAX, 1046, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8390, UINT16_MAX, 8390, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1047, UINT16_MAX, 1047, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8391, UINT16_MAX, 8391, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1048, UINT16_MAX, 1048, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8392, UINT16_MAX, 8392, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1049, UINT16_MAX, 1049, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8393, UINT16_MAX, 8393, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1050, UINT16_MAX, 1050, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8394, UINT16_MAX, 8394, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1051, UINT16_MAX, 1051, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9244, 1054, UINT16_MAX, 1054, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9247, UINT16_MAX, 8395, UINT16_MAX, 8395, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1057, UINT16_MAX, 1057, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8396, UINT16_MAX, 8396, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1058, UINT16_MAX, 1058, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8397, UINT16_MAX, 8397, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1059, UINT16_MAX, 1059, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8398, UINT16_MAX, 8398, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1060, UINT16_MAX, 1060, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8399, UINT16_MAX, 8399, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1061, UINT16_MAX, 1061, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8400, UINT16_MAX, 8400, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1062, UINT16_MAX, 1062, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8401, UINT16_MAX, 8401, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8402, UINT16_MAX, 8402, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9255, 1065, UINT16_MAX, 1065, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9258, UINT16_MAX, 8403, UINT16_MAX, 8403, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9260, 1070, UINT16_MAX, 1070, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9263, UINT16_MAX, 8404, UINT16_MAX, 8404, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1073, UINT16_MAX, 1073, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8405, UINT16_MAX, 8405, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9266, 1076, UINT16_MAX, 1076, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9269, UINT16_MAX, 8406, UINT16_MAX, 8406, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1079, UINT16_MAX, 1079, UINT16_MAX, 2629, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8407, UINT16_MAX, 8407, 2632, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9272, 1082, UINT16_MAX, 1082, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9275, UINT16_MAX, 8408, UINT16_MAX, 8408, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9277, 1087, UINT16_MAX, 1087, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9280, UINT16_MAX, 8409, UINT16_MAX, 8409, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9282, 1092, UINT16_MAX, 1092, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9285, UINT16_MAX, 8410, UINT16_MAX, 8410, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1095, UINT16_MAX, 1095, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8411, UINT16_MAX, 8411, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9288, 1098, UINT16_MAX, 1098, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9291, UINT16_MAX, 8412, UINT16_MAX, 8412, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9293, 1103, UINT16_MAX, 1103, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9296, UINT16_MAX, 8413, UINT16_MAX, 8413, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9298, 1108, UINT16_MAX, 1108, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9301, UINT16_MAX, 8414, UINT16_MAX, 8414, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1111, UINT16_MAX, 1111, UINT16_MAX, 2647, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8415, UINT16_MAX, 8415, 2650, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9304, 1114, UINT16_MAX, 1114, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9307, UINT16_MAX, 8416, UINT16_MAX, 8416, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9309, 1119, UINT16_MAX, 1119, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9312, UINT16_MAX, 8417, UINT16_MAX, 8417, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9314, 1124, UINT16_MAX, 1124, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9317, UINT16_MAX, 8418, UINT16_MAX, 8418, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9319, 1129, UINT16_MAX, 1129, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9322, UINT16_MAX, 8419, UINT16_MAX, 8419, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9324, 1134, UINT16_MAX, 1134, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9327, UINT16_MAX, 8420, UINT16_MAX, 8420, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9329, 1139, UINT16_MAX, 1139, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9332, UINT16_MAX, 8421, UINT16_MAX, 8421, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1142, UINT16_MAX, 1142, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8422, UINT16_MAX, 8422, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9335, 1145, UINT16_MAX, 1145, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9338, UINT16_MAX, 8423, UINT16_MAX, 8423, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1148, UINT16_MAX, 1148, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8424, UINT16_MAX, 8424, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1149, UINT16_MAX, 1149, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8425, UINT16_MAX, 8425, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1150, UINT16_MAX, 1150, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8426, UINT16_MAX, 8426, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1151, UINT16_MAX, 1151, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8427, UINT16_MAX, 8427, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1152, UINT16_MAX, 1152, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8428, UINT16_MAX, 8428, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1153, UINT16_MAX, 1153, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8429, UINT16_MAX, 8429, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1154, UINT16_MAX, 1154, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8430, UINT16_MAX, 8430, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1155, UINT16_MAX, 1155, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8431, UINT16_MAX, 8431, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1156, UINT16_MAX, 1156, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8432, UINT16_MAX, 8432, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1157, UINT16_MAX, 1157, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8433, UINT16_MAX, 8433, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1158, UINT16_MAX, 1158, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8434, UINT16_MAX, 8434, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1159, UINT16_MAX, 1159, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8435, UINT16_MAX, 8435, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1160, UINT16_MAX, 1160, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8436, UINT16_MAX, 8436, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1161, UINT16_MAX, 1161, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8437, UINT16_MAX, 8437, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1162, UINT16_MAX, 1162, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8438, UINT16_MAX, 8438, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1163, UINT16_MAX, 1163, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8439, UINT16_MAX, 8439, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1164, UINT16_MAX, 1164, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8440, UINT16_MAX, 8440, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1165, UINT16_MAX, 1165, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8441, UINT16_MAX, 8441, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1166, UINT16_MAX, 1166, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8442, UINT16_MAX, 8442, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1167, UINT16_MAX, 1167, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8443, UINT16_MAX, 8443, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1168, UINT16_MAX, 1168, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8444, UINT16_MAX, 8444, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1169, UINT16_MAX, 1169, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8445, UINT16_MAX, 8445, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1170, UINT16_MAX, 1170, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8446, UINT16_MAX, 8446, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1171, UINT16_MAX, 1171, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8447, UINT16_MAX, 8447, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1172, UINT16_MAX, 1172, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8448, UINT16_MAX, 8448, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1173, UINT16_MAX, 1173, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8449, UINT16_MAX, 8449, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1174, UINT16_MAX, 1174, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8450, UINT16_MAX, 8450, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1175, UINT16_MAX, 1175, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1176, UINT16_MAX, 1176, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1177, UINT16_MAX, 1177, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1178, UINT16_MAX, 1178, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1179, UINT16_MAX, 1179, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1180, UINT16_MAX, 1180, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1181, UINT16_MAX, 1181, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1182, UINT16_MAX, 1182, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1183, UINT16_MAX, 1183, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1184, UINT16_MAX, 1184, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1185, UINT16_MAX, 1185, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1186, UINT16_MAX, 1186, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1187, UINT16_MAX, 1187, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1188, UINT16_MAX, 1188, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1189, UINT16_MAX, 1189, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1190, UINT16_MAX, 1190, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1191, UINT16_MAX, 1191, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1192, UINT16_MAX, 1192, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1193, UINT16_MAX, 1193, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1194, UINT16_MAX, 1194, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1195, UINT16_MAX, 1195, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1196, UINT16_MAX, 1196, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1197, UINT16_MAX, 1197, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1198, UINT16_MAX, 1198, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1199, UINT16_MAX, 1199, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1200, UINT16_MAX, 1200, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1201, UINT16_MAX, 1201, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1202, UINT16_MAX, 1202, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1203, UINT16_MAX, 1203, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1204, UINT16_MAX, 1204, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1205, UINT16_MAX, 1205, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1206, UINT16_MAX, 1206, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1207, UINT16_MAX, 1207, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1208, UINT16_MAX, 1208, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1209, UINT16_MAX, 1209, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1210, UINT16_MAX, 1210, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1211, UINT16_MAX, 1211, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1212, UINT16_MAX, 1212, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8451, UINT16_MAX, 8451, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8452, UINT16_MAX, 8452, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8453, UINT16_MAX, 8453, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8454, UINT16_MAX, 8454, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8455, UINT16_MAX, 8455, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8456, UINT16_MAX, 8456, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8457, UINT16_MAX, 8457, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8458, UINT16_MAX, 8458, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8459, UINT16_MAX, 8459, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8460, UINT16_MAX, 8460, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8461, UINT16_MAX, 8461, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8462, UINT16_MAX, 8462, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8463, UINT16_MAX, 8463, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8464, UINT16_MAX, 8464, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8465, UINT16_MAX, 8465, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8466, UINT16_MAX, 8466, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8467, UINT16_MAX, 8467, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8468, UINT16_MAX, 8468, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8469, UINT16_MAX, 8469, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8470, UINT16_MAX, 8470, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8471, UINT16_MAX, 8471, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8472, UINT16_MAX, 8472, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8473, UINT16_MAX, 8473, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8474, UINT16_MAX, 8474, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8475, UINT16_MAX, 8475, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8476, UINT16_MAX, 8476, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8477, UINT16_MAX, 8477, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8478, UINT16_MAX, 8478, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8479, UINT16_MAX, 8479, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8480, UINT16_MAX, 8480, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8481, UINT16_MAX, 8481, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8482, UINT16_MAX, 8482, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8483, UINT16_MAX, 8483, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8484, UINT16_MAX, 8484, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8485, UINT16_MAX, 8485, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8486, UINT16_MAX, 8486, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8487, UINT16_MAX, 8487, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8488, UINT16_MAX, 8488, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 9405, 9405, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_MN, 222, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 228, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 10, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 11, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 12, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 13, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 14, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 15, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 16, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 17, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 18, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 19, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 20, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 21, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 22, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_MN, 23, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_MN, 24, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 25, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_AN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_PREPEND}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_MN, 30, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 31, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 32, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 9407, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 9409, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 9411, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 9413, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 9415, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2671, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2676, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2679, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_MN, 27, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 28, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 29, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 33, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 34, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32785, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32786, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32787, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_AN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_AN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_MN, 35, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_COMPAT, 9417, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_COMPAT, 9419, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_COMPAT, 9421, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_COMPAT, 9423, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 9425, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2685, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 9427, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2688, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 9429, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2682, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_PREPEND}, - {UTF8PROC_CATEGORY_MN, 36, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2691, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9431, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2694, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9433, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2697, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9435, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_MN, 7, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32788, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 9, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9437, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9439, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9441, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9443, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9445, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9447, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9449, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9451, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_MN, 7, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32789, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2700, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9453, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9455, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32790, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9457, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9459, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9461, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9463, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9465, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9467, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9469, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9471, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9473, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32792, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2704, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9475, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9477, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9479, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32791, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32793, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9481, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9483, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2709, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9485, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32795, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2712, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2716, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9487, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9489, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9491, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32794, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2719, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 9493, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 84, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 91, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32796, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2722, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9495, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32799, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2725, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9497, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9499, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9501, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2730, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9503, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32797, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32798, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32800, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2733, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2737, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9505, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9507, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9509, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_PREPEND}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32801, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 9, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32802, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32803, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2740, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9511, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9513, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2745, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9515, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9517, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32804, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 9519, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MN, 103, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 107, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 9521, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MN, 118, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 122, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 9523, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 9525, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NOBREAK, 1335, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_MN, 216, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9528, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9530, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9532, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9534, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9536, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9538, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_MN, 129, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 130, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 9540, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 132, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 9542, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 9544, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, UTF8PROC_DECOMP_TYPE_COMPAT, 9546, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 9548, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, UTF8PROC_DECOMP_TYPE_COMPAT, 9550, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 9552, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 9554, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 9556, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 9558, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 9560, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 9562, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 9564, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2748, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9566, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32805, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1376, UINT16_MAX, 1376, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1377, UINT16_MAX, 1377, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1378, UINT16_MAX, 1378, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1379, UINT16_MAX, 1379, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1380, UINT16_MAX, 1380, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1381, UINT16_MAX, 1381, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1382, UINT16_MAX, 1382, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1383, UINT16_MAX, 1383, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1384, UINT16_MAX, 1384, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1385, UINT16_MAX, 1385, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1386, UINT16_MAX, 1386, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1387, UINT16_MAX, 1387, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1388, UINT16_MAX, 1388, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1389, UINT16_MAX, 1389, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1390, UINT16_MAX, 1390, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1391, UINT16_MAX, 1391, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1392, UINT16_MAX, 1392, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1393, UINT16_MAX, 1393, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1394, UINT16_MAX, 1394, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1395, UINT16_MAX, 1395, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1396, UINT16_MAX, 1396, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1397, UINT16_MAX, 1397, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1398, UINT16_MAX, 1398, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1399, UINT16_MAX, 1399, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1400, UINT16_MAX, 1400, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1401, UINT16_MAX, 1401, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1402, UINT16_MAX, 1402, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1403, UINT16_MAX, 1403, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1404, UINT16_MAX, 1404, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1405, UINT16_MAX, 1405, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1406, UINT16_MAX, 1406, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1407, UINT16_MAX, 1407, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1408, UINT16_MAX, 1408, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1409, UINT16_MAX, 1409, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1410, UINT16_MAX, 1410, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1411, UINT16_MAX, 1411, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1412, UINT16_MAX, 1412, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1413, UINT16_MAX, 1413, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1414, UINT16_MAX, 1414, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1415, UINT16_MAX, 1415, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8489, UINT16_MAX, 1446, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8490, UINT16_MAX, 1447, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8491, UINT16_MAX, 1448, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8492, UINT16_MAX, 1449, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8493, UINT16_MAX, 1450, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8494, UINT16_MAX, 1451, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8495, UINT16_MAX, 1452, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8496, UINT16_MAX, 1453, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8497, UINT16_MAX, 1454, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8498, UINT16_MAX, 1455, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8499, UINT16_MAX, 1456, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8500, UINT16_MAX, 1457, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8501, UINT16_MAX, 1416, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8502, UINT16_MAX, 1458, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8503, UINT16_MAX, 1459, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8504, UINT16_MAX, 1460, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8505, UINT16_MAX, 1461, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8506, UINT16_MAX, 1462, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8507, UINT16_MAX, 1463, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8508, UINT16_MAX, 1464, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8509, UINT16_MAX, 1465, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8510, UINT16_MAX, 1466, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8511, UINT16_MAX, 1467, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8512, UINT16_MAX, 1468, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8513, UINT16_MAX, 1469, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8514, UINT16_MAX, 1470, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8515, UINT16_MAX, 1471, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8516, UINT16_MAX, 1472, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8517, UINT16_MAX, 1473, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8518, UINT16_MAX, 1474, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8519, UINT16_MAX, 1475, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8520, UINT16_MAX, 1476, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8521, UINT16_MAX, 1477, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8522, UINT16_MAX, 1478, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8523, UINT16_MAX, 1479, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8524, UINT16_MAX, 1480, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8525, UINT16_MAX, 1481, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8526, UINT16_MAX, 1482, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8527, UINT16_MAX, 1483, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8528, UINT16_MAX, 1484, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8529, UINT16_MAX, 1485, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8530, UINT16_MAX, 1486, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8531, UINT16_MAX, 1487, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1416, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8532, UINT16_MAX, 1488, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8533, UINT16_MAX, 1489, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8534, UINT16_MAX, 1490, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_L}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, false, 2, 0, UTF8PROC_BOUNDCLASS_L}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, false, 1, 0, UTF8PROC_BOUNDCLASS_V}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_V}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_T}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8535, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8536, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8537, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8538, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8539, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8540, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8541, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8542, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8543, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8544, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8545, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8546, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8547, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8548, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8549, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8550, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8551, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8552, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8553, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8554, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8555, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8556, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8557, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8558, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8559, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8560, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8561, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8562, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8563, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8564, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8565, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8566, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8567, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8568, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8569, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8570, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8571, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8572, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8573, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8574, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8575, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8576, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8577, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8578, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8579, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8580, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8581, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8582, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8583, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8584, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8585, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8586, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8587, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8588, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8589, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8590, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8591, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8592, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8593, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8594, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8595, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8596, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8597, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8598, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8599, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8600, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8601, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8602, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8603, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8604, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8605, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8606, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8607, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8608, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8609, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8610, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8611, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8612, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8613, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8614, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8615, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8616, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8617, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8618, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8619, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8620, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1417, 1417, UINT16_MAX, 1417, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1418, 1418, UINT16_MAX, 1418, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1419, 1419, UINT16_MAX, 1419, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1420, 1420, UINT16_MAX, 1420, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1421, 1421, UINT16_MAX, 1421, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1422, 1422, UINT16_MAX, 1422, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_BN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2751, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9615, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2754, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9617, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2757, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9619, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2760, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9621, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2763, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9623, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2766, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9625, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32806, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2769, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9627, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2772, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9629, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2775, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2778, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9631, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9633, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2781, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9635, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 9, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 955, 8305, UINT16_MAX, 8305, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 957, 8307, UINT16_MAX, 8307, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 969, 8317, UINT16_MAX, 8317, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 972, 8320, UINT16_MAX, 8320, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 973, 8321, UINT16_MAX, 8321, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 981, 8329, UINT16_MAX, 8329, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1004, 8352, UINT16_MAX, 8352, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1445, 8621, UINT16_MAX, 8621, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1446, UINT16_MAX, 1446, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1447, UINT16_MAX, 1447, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1448, UINT16_MAX, 1448, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1449, UINT16_MAX, 1449, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1450, UINT16_MAX, 1450, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1451, UINT16_MAX, 1451, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1452, UINT16_MAX, 1452, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1453, UINT16_MAX, 1453, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1454, UINT16_MAX, 1454, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1455, UINT16_MAX, 1455, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1456, UINT16_MAX, 1456, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1457, UINT16_MAX, 1457, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1416, UINT16_MAX, 1416, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1458, UINT16_MAX, 1458, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1459, UINT16_MAX, 1459, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1460, UINT16_MAX, 1460, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1461, UINT16_MAX, 1461, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1462, UINT16_MAX, 1462, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1463, UINT16_MAX, 1463, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1464, UINT16_MAX, 1464, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1465, UINT16_MAX, 1465, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1466, UINT16_MAX, 1466, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1467, UINT16_MAX, 1467, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1468, UINT16_MAX, 1468, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1469, UINT16_MAX, 1469, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1470, UINT16_MAX, 1470, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1471, UINT16_MAX, 1471, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1472, UINT16_MAX, 1472, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1473, UINT16_MAX, 1473, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1474, UINT16_MAX, 1474, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1475, UINT16_MAX, 1475, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1476, UINT16_MAX, 1476, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1477, UINT16_MAX, 1477, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1478, UINT16_MAX, 1478, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1479, UINT16_MAX, 1479, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1480, UINT16_MAX, 1480, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1481, UINT16_MAX, 1481, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1482, UINT16_MAX, 1482, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1483, UINT16_MAX, 1483, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1484, UINT16_MAX, 1484, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1485, UINT16_MAX, 1485, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1486, UINT16_MAX, 1486, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1487, UINT16_MAX, 1487, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1488, UINT16_MAX, 1488, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1489, UINT16_MAX, 1489, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1490, UINT16_MAX, 1490, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1491, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1492, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1493, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1494, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1495, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1496, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1497, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1498, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1499, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1500, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1501, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1502, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1503, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1504, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1505, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1506, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1507, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1508, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1509, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1510, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1511, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1512, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1513, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1514, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 4, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 485, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 486, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1515, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 6, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 10, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 12, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 355, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 14, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 479, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1516, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1517, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 15, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 19, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 20, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1518, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 493, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 21, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1519, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 846, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 847, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 848, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 863, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 864, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 8, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 17, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 20, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 21, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 846, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 847, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 859, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 863, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 864, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 968, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8622, UINT16_MAX, 8622, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8623, UINT16_MAX, 8623, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8624, UINT16_MAX, 8624, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1520, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1521, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 94, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1522, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1523, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1524, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 491, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 490, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1525, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1526, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1527, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1528, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1529, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1530, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1531, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1532, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 494, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1533, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1534, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 495, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1535, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1536, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 505, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1537, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 778, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 513, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1538, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 514, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 779, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 25, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1539, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1540, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 517, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 852, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_MN, 214, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9733, 1543, UINT16_MAX, 1543, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9736, UINT16_MAX, 8625, UINT16_MAX, 8625, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9738, 1548, UINT16_MAX, 1548, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9741, UINT16_MAX, 8626, UINT16_MAX, 8626, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9743, 1553, UINT16_MAX, 1553, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9746, UINT16_MAX, 8627, UINT16_MAX, 8627, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9748, 1558, UINT16_MAX, 1558, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9751, UINT16_MAX, 8628, UINT16_MAX, 8628, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9753, 1563, UINT16_MAX, 1563, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9756, UINT16_MAX, 8629, UINT16_MAX, 8629, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9758, 1568, UINT16_MAX, 1568, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9761, UINT16_MAX, 8630, UINT16_MAX, 8630, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9763, 1573, UINT16_MAX, 1573, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9766, UINT16_MAX, 8631, UINT16_MAX, 8631, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9768, 1578, UINT16_MAX, 1578, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9771, UINT16_MAX, 8632, UINT16_MAX, 8632, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9773, 1583, UINT16_MAX, 1583, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9776, UINT16_MAX, 8633, UINT16_MAX, 8633, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9778, 1588, UINT16_MAX, 1588, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9781, UINT16_MAX, 8634, UINT16_MAX, 8634, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9783, 1593, UINT16_MAX, 1593, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9786, UINT16_MAX, 8635, UINT16_MAX, 8635, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9788, 1598, UINT16_MAX, 1598, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9791, UINT16_MAX, 8636, UINT16_MAX, 8636, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9793, 1603, UINT16_MAX, 1603, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9796, UINT16_MAX, 8637, UINT16_MAX, 8637, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9798, 1608, UINT16_MAX, 1608, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9801, UINT16_MAX, 8638, UINT16_MAX, 8638, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9803, 1613, UINT16_MAX, 1613, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9806, UINT16_MAX, 8639, UINT16_MAX, 8639, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9808, 1618, UINT16_MAX, 1618, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9811, UINT16_MAX, 8640, UINT16_MAX, 8640, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9813, 1623, UINT16_MAX, 1623, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9816, UINT16_MAX, 8641, UINT16_MAX, 8641, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9818, 1628, UINT16_MAX, 1628, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9821, UINT16_MAX, 8642, UINT16_MAX, 8642, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9823, 1633, UINT16_MAX, 1633, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9826, UINT16_MAX, 8643, UINT16_MAX, 8643, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9828, 1638, UINT16_MAX, 1638, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9831, UINT16_MAX, 8644, UINT16_MAX, 8644, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9833, 1643, UINT16_MAX, 1643, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9836, UINT16_MAX, 8645, UINT16_MAX, 8645, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9838, 1648, UINT16_MAX, 1648, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9841, UINT16_MAX, 8646, UINT16_MAX, 8646, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9843, 1653, UINT16_MAX, 1653, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9846, UINT16_MAX, 8647, UINT16_MAX, 8647, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9848, 1658, UINT16_MAX, 1658, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9851, UINT16_MAX, 8648, UINT16_MAX, 8648, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9853, 1663, UINT16_MAX, 1663, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9856, UINT16_MAX, 8649, UINT16_MAX, 8649, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9858, 1668, UINT16_MAX, 1668, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9861, UINT16_MAX, 8650, UINT16_MAX, 8650, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9863, 1673, UINT16_MAX, 1673, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9866, UINT16_MAX, 8651, UINT16_MAX, 8651, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9868, 1678, UINT16_MAX, 1678, UINT16_MAX, 2884, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9871, UINT16_MAX, 8652, UINT16_MAX, 8652, 2887, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9873, 1683, UINT16_MAX, 1683, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9876, UINT16_MAX, 8653, UINT16_MAX, 8653, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9878, 1688, UINT16_MAX, 1688, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9881, UINT16_MAX, 8654, UINT16_MAX, 8654, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9883, 1693, UINT16_MAX, 1693, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9886, UINT16_MAX, 8655, UINT16_MAX, 8655, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9888, 1698, UINT16_MAX, 1698, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9891, UINT16_MAX, 8656, UINT16_MAX, 8656, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9893, 1703, UINT16_MAX, 1703, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9896, UINT16_MAX, 8657, UINT16_MAX, 8657, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9898, 1708, UINT16_MAX, 1708, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9901, UINT16_MAX, 8658, UINT16_MAX, 8658, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9903, 1713, UINT16_MAX, 1713, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9906, UINT16_MAX, 8659, UINT16_MAX, 8659, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9908, 1718, UINT16_MAX, 1718, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9911, UINT16_MAX, 8660, UINT16_MAX, 8660, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9913, 1723, UINT16_MAX, 1723, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9916, UINT16_MAX, 8661, UINT16_MAX, 8661, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9918, 1728, UINT16_MAX, 1728, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9921, UINT16_MAX, 8662, UINT16_MAX, 8662, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9923, 1733, UINT16_MAX, 1733, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9926, UINT16_MAX, 8663, UINT16_MAX, 8663, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9928, 1738, UINT16_MAX, 1738, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9931, UINT16_MAX, 8664, UINT16_MAX, 8664, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9933, 1743, UINT16_MAX, 1743, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9936, UINT16_MAX, 8665, UINT16_MAX, 8665, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9938, 1748, UINT16_MAX, 1748, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9941, UINT16_MAX, 8666, UINT16_MAX, 8666, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9943, 1753, UINT16_MAX, 1753, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9946, UINT16_MAX, 8667, UINT16_MAX, 8667, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9948, 1758, UINT16_MAX, 1758, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9951, UINT16_MAX, 8668, UINT16_MAX, 8668, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9953, 1763, UINT16_MAX, 1763, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9956, UINT16_MAX, 8669, UINT16_MAX, 8669, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9958, 1768, UINT16_MAX, 1768, UINT16_MAX, 3006, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9961, UINT16_MAX, 8670, UINT16_MAX, 8670, 3009, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9963, 1773, UINT16_MAX, 1773, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9966, UINT16_MAX, 8671, UINT16_MAX, 8671, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9968, 1778, UINT16_MAX, 1778, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9971, UINT16_MAX, 8672, UINT16_MAX, 8672, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9973, 1783, UINT16_MAX, 1783, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9976, UINT16_MAX, 8673, UINT16_MAX, 8673, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9978, 1788, UINT16_MAX, 1788, UINT16_MAX, 3024, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9981, UINT16_MAX, 8674, UINT16_MAX, 8674, 3027, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9983, 1793, UINT16_MAX, 1793, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9986, UINT16_MAX, 8675, UINT16_MAX, 8675, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9988, 1798, UINT16_MAX, 1798, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9991, UINT16_MAX, 8676, UINT16_MAX, 8676, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9993, 1803, UINT16_MAX, 1803, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9996, UINT16_MAX, 8677, UINT16_MAX, 8677, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9998, 1808, UINT16_MAX, 1808, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10001, UINT16_MAX, 8678, UINT16_MAX, 8678, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10003, 1813, UINT16_MAX, 1813, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10006, UINT16_MAX, 8679, UINT16_MAX, 8679, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10008, 1818, UINT16_MAX, 1818, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10011, UINT16_MAX, 8680, UINT16_MAX, 8680, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10013, 1823, UINT16_MAX, 1823, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10016, UINT16_MAX, 8681, UINT16_MAX, 8681, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10018, 1828, UINT16_MAX, 1828, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10021, UINT16_MAX, 8682, UINT16_MAX, 8682, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10023, 1833, UINT16_MAX, 1833, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10026, UINT16_MAX, 8683, UINT16_MAX, 8683, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10028, 1838, UINT16_MAX, 1838, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10031, UINT16_MAX, 8684, UINT16_MAX, 8684, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10033, 1843, UINT16_MAX, 1843, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10036, UINT16_MAX, 8685, UINT16_MAX, 8685, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10038, 1848, UINT16_MAX, 1848, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10041, UINT16_MAX, 8686, UINT16_MAX, 8686, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10043, 1853, UINT16_MAX, 1853, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10046, UINT16_MAX, 8687, UINT16_MAX, 8687, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10048, 1858, UINT16_MAX, 1858, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10051, UINT16_MAX, 8688, UINT16_MAX, 8688, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10053, 1863, UINT16_MAX, 1863, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10056, UINT16_MAX, 8689, UINT16_MAX, 8689, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10058, 1868, UINT16_MAX, 1868, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10061, UINT16_MAX, 8690, UINT16_MAX, 8690, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10063, 1873, UINT16_MAX, 1873, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10066, UINT16_MAX, 8691, UINT16_MAX, 8691, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10068, 1878, UINT16_MAX, 1878, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10071, UINT16_MAX, 8692, UINT16_MAX, 8692, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10073, 1883, UINT16_MAX, 1883, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10076, UINT16_MAX, 8693, UINT16_MAX, 8693, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10078, 1888, UINT16_MAX, 1888, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10081, UINT16_MAX, 8694, UINT16_MAX, 8694, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10083, 1893, UINT16_MAX, 1893, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10086, UINT16_MAX, 8695, UINT16_MAX, 8695, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10088, 1898, UINT16_MAX, 1898, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10091, UINT16_MAX, 8696, UINT16_MAX, 8696, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10093, 1903, UINT16_MAX, 1903, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10096, UINT16_MAX, 8697, UINT16_MAX, 8697, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10098, 1908, UINT16_MAX, 1908, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10101, UINT16_MAX, 8698, UINT16_MAX, 8698, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10103, 1913, UINT16_MAX, 1913, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10106, UINT16_MAX, 8699, UINT16_MAX, 8699, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10108, 10108, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10110, 10110, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10112, 10112, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10114, 10114, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 10116, 10116, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10118, 1783, 8673, UINT16_MAX, 8673, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8322, UINT16_MAX, 8700, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10120, 1930, UINT16_MAX, 1930, UINT16_MAX, 3241, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10123, UINT16_MAX, 8701, UINT16_MAX, 8701, 3250, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10125, 1935, UINT16_MAX, 1935, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10128, UINT16_MAX, 8702, UINT16_MAX, 8702, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10130, 1940, UINT16_MAX, 1940, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10133, UINT16_MAX, 8703, UINT16_MAX, 8703, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10135, 1945, UINT16_MAX, 1945, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10138, UINT16_MAX, 8704, UINT16_MAX, 8704, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10140, 1950, UINT16_MAX, 1950, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10143, UINT16_MAX, 8705, UINT16_MAX, 8705, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10145, 1955, UINT16_MAX, 1955, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10148, UINT16_MAX, 8706, UINT16_MAX, 8706, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10150, 1960, UINT16_MAX, 1960, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10153, UINT16_MAX, 8707, UINT16_MAX, 8707, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10155, 1965, UINT16_MAX, 1965, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10158, UINT16_MAX, 8708, UINT16_MAX, 8708, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10160, 1970, UINT16_MAX, 1970, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10163, UINT16_MAX, 8709, UINT16_MAX, 8709, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10165, 1975, UINT16_MAX, 1975, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10168, UINT16_MAX, 8710, UINT16_MAX, 8710, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10170, 1980, UINT16_MAX, 1980, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10173, UINT16_MAX, 8711, UINT16_MAX, 8711, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10175, 1985, UINT16_MAX, 1985, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10178, UINT16_MAX, 8712, UINT16_MAX, 8712, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10180, 1990, UINT16_MAX, 1990, UINT16_MAX, 3455, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10183, UINT16_MAX, 8713, UINT16_MAX, 8713, 3458, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10185, 1995, UINT16_MAX, 1995, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10188, UINT16_MAX, 8714, UINT16_MAX, 8714, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10190, 2000, UINT16_MAX, 2000, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10193, UINT16_MAX, 8715, UINT16_MAX, 8715, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10195, 2005, UINT16_MAX, 2005, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10198, UINT16_MAX, 8716, UINT16_MAX, 8716, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10200, 2010, UINT16_MAX, 2010, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10203, UINT16_MAX, 8717, UINT16_MAX, 8717, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10205, 2015, UINT16_MAX, 2015, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10208, UINT16_MAX, 8718, UINT16_MAX, 8718, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10210, 2020, UINT16_MAX, 2020, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10213, UINT16_MAX, 8719, UINT16_MAX, 8719, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10215, 2025, UINT16_MAX, 2025, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10218, UINT16_MAX, 8720, UINT16_MAX, 8720, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10220, 2030, UINT16_MAX, 2030, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10223, UINT16_MAX, 8721, UINT16_MAX, 8721, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10225, 2035, UINT16_MAX, 2035, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10228, UINT16_MAX, 8722, UINT16_MAX, 8722, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10230, 2040, UINT16_MAX, 2040, UINT16_MAX, 3559, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10233, UINT16_MAX, 8723, UINT16_MAX, 8723, 3562, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10235, 2045, UINT16_MAX, 2045, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10238, UINT16_MAX, 8724, UINT16_MAX, 8724, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10240, 2050, UINT16_MAX, 2050, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10243, UINT16_MAX, 8725, UINT16_MAX, 8725, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10245, 2055, UINT16_MAX, 2055, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10248, UINT16_MAX, 8726, UINT16_MAX, 8726, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10250, 2060, UINT16_MAX, 2060, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10253, UINT16_MAX, 8727, UINT16_MAX, 8727, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10255, 2065, UINT16_MAX, 2065, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10258, UINT16_MAX, 8728, UINT16_MAX, 8728, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10260, 2070, UINT16_MAX, 2070, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10263, UINT16_MAX, 8729, UINT16_MAX, 8729, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10265, 2075, UINT16_MAX, 2075, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10268, UINT16_MAX, 8730, UINT16_MAX, 8730, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10270, 2080, UINT16_MAX, 2080, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10273, UINT16_MAX, 8731, UINT16_MAX, 8731, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10275, 2085, UINT16_MAX, 2085, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10278, UINT16_MAX, 8732, UINT16_MAX, 8732, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10280, 2090, UINT16_MAX, 2090, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10283, UINT16_MAX, 8733, UINT16_MAX, 8733, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10285, 2095, UINT16_MAX, 2095, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10288, UINT16_MAX, 8734, UINT16_MAX, 8734, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10290, 2100, UINT16_MAX, 2100, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10293, UINT16_MAX, 8735, UINT16_MAX, 8735, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10295, 2105, UINT16_MAX, 2105, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10298, UINT16_MAX, 8736, UINT16_MAX, 8736, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10300, 2110, UINT16_MAX, 2110, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10303, UINT16_MAX, 8737, UINT16_MAX, 8737, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10305, 2115, UINT16_MAX, 2115, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10308, UINT16_MAX, 8738, UINT16_MAX, 8738, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10310, 2120, UINT16_MAX, 2120, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10313, UINT16_MAX, 8739, UINT16_MAX, 8739, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10315, 2125, UINT16_MAX, 2125, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10318, UINT16_MAX, 8740, UINT16_MAX, 8740, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10320, 2130, UINT16_MAX, 2130, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10323, UINT16_MAX, 8741, UINT16_MAX, 8741, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10325, 2135, UINT16_MAX, 2135, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10328, UINT16_MAX, 8742, UINT16_MAX, 8742, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10330, 2140, UINT16_MAX, 2140, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10333, UINT16_MAX, 8743, UINT16_MAX, 8743, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10335, 2145, UINT16_MAX, 2145, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10338, UINT16_MAX, 8744, UINT16_MAX, 8744, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10340, 2150, UINT16_MAX, 2150, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10343, UINT16_MAX, 8745, UINT16_MAX, 8745, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2153, UINT16_MAX, 2153, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8746, UINT16_MAX, 8746, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2154, UINT16_MAX, 2154, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8747, UINT16_MAX, 8747, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2155, UINT16_MAX, 2155, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8748, UINT16_MAX, 8748, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10348, UINT16_MAX, 8749, UINT16_MAX, 8749, 3761, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10350, UINT16_MAX, 8750, UINT16_MAX, 8750, 3814, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10352, UINT16_MAX, 8751, UINT16_MAX, 8751, 4793, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10354, UINT16_MAX, 8752, UINT16_MAX, 8752, 4796, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10356, UINT16_MAX, 8753, UINT16_MAX, 8753, 4799, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10358, UINT16_MAX, 8754, UINT16_MAX, 8754, 4802, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10360, UINT16_MAX, 8755, UINT16_MAX, 8755, 4805, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10362, UINT16_MAX, 8756, UINT16_MAX, 8756, 4808, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10364, 2174, UINT16_MAX, 2174, UINT16_MAX, 3867, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10367, 2177, UINT16_MAX, 2177, UINT16_MAX, 3920, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10370, 2180, UINT16_MAX, 2180, UINT16_MAX, 4811, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10373, 2183, UINT16_MAX, 2183, UINT16_MAX, 4814, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10376, 2186, UINT16_MAX, 2186, UINT16_MAX, 4817, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10379, 2189, UINT16_MAX, 2189, UINT16_MAX, 4820, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10382, 2192, UINT16_MAX, 2192, UINT16_MAX, 4823, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10385, 2195, UINT16_MAX, 2195, UINT16_MAX, 4826, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10388, UINT16_MAX, 8757, UINT16_MAX, 8757, 3973, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10390, UINT16_MAX, 8758, UINT16_MAX, 8758, 3977, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10392, UINT16_MAX, 8759, UINT16_MAX, 8759, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10394, UINT16_MAX, 8760, UINT16_MAX, 8760, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10396, UINT16_MAX, 8761, UINT16_MAX, 8761, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10398, UINT16_MAX, 8762, UINT16_MAX, 8762, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10400, 2210, UINT16_MAX, 2210, UINT16_MAX, 3981, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10403, 2213, UINT16_MAX, 2213, UINT16_MAX, 3985, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10406, 2216, UINT16_MAX, 2216, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10409, 2219, UINT16_MAX, 2219, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10412, 2222, UINT16_MAX, 2222, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10415, 2225, UINT16_MAX, 2225, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10418, UINT16_MAX, 8763, UINT16_MAX, 8763, 3989, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10420, UINT16_MAX, 8764, UINT16_MAX, 8764, 4042, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10422, UINT16_MAX, 8765, UINT16_MAX, 8765, 4829, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10424, UINT16_MAX, 8766, UINT16_MAX, 8766, 4832, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10426, UINT16_MAX, 8767, UINT16_MAX, 8767, 4835, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10428, UINT16_MAX, 8768, UINT16_MAX, 8768, 4838, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10430, UINT16_MAX, 8769, UINT16_MAX, 8769, 4841, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10432, UINT16_MAX, 8770, UINT16_MAX, 8770, 4844, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10434, 2244, UINT16_MAX, 2244, UINT16_MAX, 4095, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10437, 2247, UINT16_MAX, 2247, UINT16_MAX, 4148, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10440, 2250, UINT16_MAX, 2250, UINT16_MAX, 4847, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10443, 2253, UINT16_MAX, 2253, UINT16_MAX, 4850, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10446, 2256, UINT16_MAX, 2256, UINT16_MAX, 4853, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10449, 2259, UINT16_MAX, 2259, UINT16_MAX, 4856, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10452, 2262, UINT16_MAX, 2262, UINT16_MAX, 4859, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10455, 2265, UINT16_MAX, 2265, UINT16_MAX, 4862, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10458, UINT16_MAX, 8771, UINT16_MAX, 8771, 4201, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10460, UINT16_MAX, 8772, UINT16_MAX, 8772, 4253, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10462, UINT16_MAX, 8773, UINT16_MAX, 8773, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10464, UINT16_MAX, 8774, UINT16_MAX, 8774, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10466, UINT16_MAX, 8775, UINT16_MAX, 8775, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10468, UINT16_MAX, 8776, UINT16_MAX, 8776, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10470, UINT16_MAX, 8777, UINT16_MAX, 8777, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10472, UINT16_MAX, 8778, UINT16_MAX, 8778, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10474, 2284, UINT16_MAX, 2284, UINT16_MAX, 4305, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10477, 2287, UINT16_MAX, 2287, UINT16_MAX, 4357, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10480, 2290, UINT16_MAX, 2290, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10483, 2293, UINT16_MAX, 2293, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10486, 2296, UINT16_MAX, 2296, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10489, 2299, UINT16_MAX, 2299, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10492, 2302, UINT16_MAX, 2302, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10495, 2305, UINT16_MAX, 2305, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10498, UINT16_MAX, 8779, UINT16_MAX, 8779, 4409, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10500, UINT16_MAX, 8780, UINT16_MAX, 8780, 4413, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10502, UINT16_MAX, 8781, UINT16_MAX, 8781, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10504, UINT16_MAX, 8782, UINT16_MAX, 8782, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10506, UINT16_MAX, 8783, UINT16_MAX, 8783, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10508, UINT16_MAX, 8784, UINT16_MAX, 8784, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10510, 2320, UINT16_MAX, 2320, UINT16_MAX, 4417, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10513, 2323, UINT16_MAX, 2323, UINT16_MAX, 4421, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10516, 2326, UINT16_MAX, 2326, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10519, 2329, UINT16_MAX, 2329, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10522, 2332, UINT16_MAX, 2332, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10525, 2335, UINT16_MAX, 2335, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10528, 10528, UINT16_MAX, UINT16_MAX, UINT16_MAX, 4425, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10530, UINT16_MAX, 8785, UINT16_MAX, 8785, 4477, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10532, 18726, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10537, UINT16_MAX, 8786, UINT16_MAX, 8786, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10539, 18733, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10544, UINT16_MAX, 8787, UINT16_MAX, 8787, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10546, 18740, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10551, UINT16_MAX, 8788, UINT16_MAX, 8788, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10553, 2363, UINT16_MAX, 2363, UINT16_MAX, 4529, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10556, 2366, UINT16_MAX, 2366, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10559, 2369, UINT16_MAX, 2369, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10562, 2372, UINT16_MAX, 2372, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10565, UINT16_MAX, 8789, UINT16_MAX, 8789, 4581, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10567, UINT16_MAX, 8790, UINT16_MAX, 8790, 4634, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10569, UINT16_MAX, 8791, UINT16_MAX, 8791, 4865, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10571, UINT16_MAX, 8792, UINT16_MAX, 8792, 4868, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10573, UINT16_MAX, 8793, UINT16_MAX, 8793, 4871, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10575, UINT16_MAX, 8794, UINT16_MAX, 8794, 4874, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10577, UINT16_MAX, 8795, UINT16_MAX, 8795, 4877, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10579, UINT16_MAX, 8796, UINT16_MAX, 8796, 4880, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10581, 2391, UINT16_MAX, 2391, UINT16_MAX, 4687, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10584, 2394, UINT16_MAX, 2394, UINT16_MAX, 4740, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10587, 2397, UINT16_MAX, 2397, UINT16_MAX, 4883, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10590, 2400, UINT16_MAX, 2400, UINT16_MAX, 4886, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10593, 2403, UINT16_MAX, 2403, UINT16_MAX, 4889, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10596, 2406, UINT16_MAX, 2406, UINT16_MAX, 4892, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10599, 2409, UINT16_MAX, 2409, UINT16_MAX, 4895, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10602, 2412, UINT16_MAX, 2412, UINT16_MAX, 4898, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10605, UINT16_MAX, 8797, UINT16_MAX, 8797, 4901, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 820, UINT16_MAX, 8798, UINT16_MAX, 8798, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10607, UINT16_MAX, 8799, UINT16_MAX, 8799, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 824, UINT16_MAX, 8800, UINT16_MAX, 8800, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10609, UINT16_MAX, 8801, UINT16_MAX, 8801, 4910, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 827, UINT16_MAX, 8802, UINT16_MAX, 8802, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10611, UINT16_MAX, 8803, UINT16_MAX, 8803, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 830, UINT16_MAX, 8804, UINT16_MAX, 8804, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10613, UINT16_MAX, 8805, UINT16_MAX, 8805, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 833, UINT16_MAX, 8806, UINT16_MAX, 8806, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10615, UINT16_MAX, 8807, UINT16_MAX, 8807, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 836, UINT16_MAX, 8808, UINT16_MAX, 8808, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10617, UINT16_MAX, 8809, UINT16_MAX, 8809, 5030, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 839, UINT16_MAX, 8810, UINT16_MAX, 8810, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10619, 10621, 8811, UINT16_MAX, 8811, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10623, 10625, 8812, UINT16_MAX, 8812, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10627, 10629, 8813, UINT16_MAX, 8813, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10631, 10633, 8814, UINT16_MAX, 8814, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10635, 10637, 8815, UINT16_MAX, 8815, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10639, 10641, 8816, UINT16_MAX, 8816, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10643, 10645, 8817, UINT16_MAX, 8817, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10647, 10649, 8818, UINT16_MAX, 8818, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10651, 10621, UINT16_MAX, 8819, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10653, 10625, UINT16_MAX, 8820, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10655, 10629, UINT16_MAX, 8821, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10657, 10633, UINT16_MAX, 8822, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10659, 10637, UINT16_MAX, 8823, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10661, 10641, UINT16_MAX, 8824, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10663, 10645, UINT16_MAX, 8825, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10665, 10649, UINT16_MAX, 8826, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10667, 10669, 8827, UINT16_MAX, 8827, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10671, 10673, 8828, UINT16_MAX, 8828, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10675, 10677, 8829, UINT16_MAX, 8829, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10679, 10681, 8830, UINT16_MAX, 8830, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10683, 10685, 8831, UINT16_MAX, 8831, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10687, 10689, 8832, UINT16_MAX, 8832, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10691, 10693, 8833, UINT16_MAX, 8833, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10695, 10697, 8834, UINT16_MAX, 8834, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10699, 10669, UINT16_MAX, 8835, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10701, 10673, UINT16_MAX, 8836, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10703, 10677, UINT16_MAX, 8837, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10705, 10681, UINT16_MAX, 8838, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10707, 10685, UINT16_MAX, 8839, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10709, 10689, UINT16_MAX, 8840, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10711, 10693, UINT16_MAX, 8841, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10713, 10697, UINT16_MAX, 8842, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10715, 10717, 8843, UINT16_MAX, 8843, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10719, 10721, 8844, UINT16_MAX, 8844, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10723, 10725, 8845, UINT16_MAX, 8845, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10727, 10729, 8846, UINT16_MAX, 8846, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10731, 10733, 8847, UINT16_MAX, 8847, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10735, 10737, 8848, UINT16_MAX, 8848, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10739, 10741, 8849, UINT16_MAX, 8849, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10743, 10745, 8850, UINT16_MAX, 8850, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10747, 10717, UINT16_MAX, 8851, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10749, 10721, UINT16_MAX, 8852, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10751, 10725, UINT16_MAX, 8853, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10753, 10729, UINT16_MAX, 8854, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10755, 10733, UINT16_MAX, 8855, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10757, 10737, UINT16_MAX, 8856, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10759, 10741, UINT16_MAX, 8857, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10761, 10745, UINT16_MAX, 8858, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10763, UINT16_MAX, 8859, UINT16_MAX, 8859, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10765, UINT16_MAX, 8860, UINT16_MAX, 8860, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10767, 10769, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10771, 10773, 8861, UINT16_MAX, 8861, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10775, 10777, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10779, 10779, UINT16_MAX, UINT16_MAX, UINT16_MAX, 4907, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10781, 18975, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10786, 2596, UINT16_MAX, 2596, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10789, 2599, UINT16_MAX, 2599, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10792, 2602, UINT16_MAX, 2602, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 2603, 2604, UINT16_MAX, 2604, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10797, 10773, UINT16_MAX, 8862, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 10799, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 807, 807, 7217, UINT16_MAX, 7217, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 10799, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 4919, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 10801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 10803, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10805, 10807, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10809, 10811, 8863, UINT16_MAX, 8863, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10813, 10815, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10817, 10817, UINT16_MAX, UINT16_MAX, UINT16_MAX, 4916, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10819, 19013, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10824, 2634, UINT16_MAX, 2634, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 2635, 2636, UINT16_MAX, 2636, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10829, 2639, UINT16_MAX, 2639, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 2640, 2641, UINT16_MAX, 2641, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10834, 10811, UINT16_MAX, 8864, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 10836, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 10838, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 10840, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10842, UINT16_MAX, 8865, UINT16_MAX, 8865, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10844, UINT16_MAX, 8866, UINT16_MAX, 8866, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10846, 19040, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 2659, 17226, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10852, 10852, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10854, 19048, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10859, 2669, UINT16_MAX, 2669, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10862, 2672, UINT16_MAX, 2672, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10865, 2675, UINT16_MAX, 2675, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 2676, 2677, UINT16_MAX, 2677, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 10870, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 10872, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 10874, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10876, UINT16_MAX, 8867, UINT16_MAX, 8867, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10878, UINT16_MAX, 8868, UINT16_MAX, 8868, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10880, 19074, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 2693, 17267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10886, 10886, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10888, UINT16_MAX, 8869, UINT16_MAX, 8869, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10890, 10890, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10892, 19086, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10897, 2707, UINT16_MAX, 2707, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10900, 2710, UINT16_MAX, 2710, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10903, 2713, UINT16_MAX, 2713, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 2714, 2715, UINT16_MAX, 2715, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10908, 2718, UINT16_MAX, 2718, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 10911, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 2721, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 2722, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10915, 10917, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10919, 10921, 8870, UINT16_MAX, 8870, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10923, 10925, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10927, 10927, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5036, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10929, 19123, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10934, 2744, UINT16_MAX, 2744, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 2745, 2746, UINT16_MAX, 2746, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10939, 2749, UINT16_MAX, 2749, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 2750, 2751, UINT16_MAX, 2751, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10944, 10921, UINT16_MAX, 8871, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 2754, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 10947, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 4971, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_ZS, 0, UTF8PROC_BIDI_CLASS_WS, 0, 2757, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_ZS, 0, UTF8PROC_BIDI_CLASS_WS, 0, 2758, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_ZS, 0, UTF8PROC_BIDI_CLASS_WS, UTF8PROC_DECOMP_TYPE_COMPAT, 26, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_ZS, 0, UTF8PROC_BIDI_CLASS_WS, UTF8PROC_DECOMP_TYPE_NOBREAK, 26, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_BN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_BN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_ZWJ}, - {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL}, - {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL}, - {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NOBREAK, 2759, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 10952, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PI, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PF, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 2762, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 10955, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19149, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_ZL, 0, UTF8PROC_BIDI_CLASS_WS, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL}, - {UTF8PROC_CATEGORY_ZP, 0, UTF8PROC_BIDI_CLASS_B, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL}, - {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_LRE, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL}, - {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_RLE, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL}, - {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_PDF, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL}, - {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_LRO, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL}, - {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_RLO, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_COMPAT, 10960, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_COMPAT, 19154, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 10965, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19159, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 10970, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 10972, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_CS, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 10974, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 10976, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 10978, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 27364, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_LRI, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL}, - {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_RLI, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL}, - {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_FSI, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL}, - {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_PDI, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 2792, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 8, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 2793, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 2794, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 2795, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 2796, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 2797, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 2798, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_SUPER, 2799, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_SUPER, 2800, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 2801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 2802, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 2803, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 13, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 2792, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 38, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 31, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 32, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 2793, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 2794, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 2795, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 2796, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 2797, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 2798, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_SUB, 2799, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_SUB, 2800, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUB, 2801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUB, 2802, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUB, 2803, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 4, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 14, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 23, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 485, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 7, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 10, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 11, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 12, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 13, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 15, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 18, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 19, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_COMPAT, 10996, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19190, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19193, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2812, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 11005, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19199, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19202, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 2821, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 11014, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 6, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1498, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 277, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1499, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1502, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 11, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1504, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 11016, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1507, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2826, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1508, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 11019, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19213, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 11024, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2834, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 2835, 866, UINT16_MAX, 866, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 1501, 10, UINT16_MAX, 10, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 2836, 65, UINT16_MAX, 65, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1493, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 4, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1495, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2837, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2838, UINT16_MAX, 2838, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1503, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 14, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 2839, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 2840, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 2841, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 2842, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19227, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 858, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 847, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2846, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2847, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FONT, 2848, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1494, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 9, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8872, UINT16_MAX, 8872, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 19233, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 19236, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 27431, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 19243, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 19246, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 19249, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 19252, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 19255, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 19258, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 19261, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 19264, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 19267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 19270, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 19273, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 19276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 11087, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1499, 2897, UINT16_MAX, 2897, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 11090, 2900, UINT16_MAX, 2900, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19285, 2904, UINT16_MAX, 2904, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 11097, 2907, UINT16_MAX, 2907, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 2908, 2909, UINT16_MAX, 2909, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 11102, 2912, UINT16_MAX, 2912, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19297, 2916, UINT16_MAX, 2916, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 27493, 2921, UINT16_MAX, 2921, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 11114, 2924, UINT16_MAX, 2924, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 2925, 2926, UINT16_MAX, 2926, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 11119, 2929, UINT16_MAX, 2929, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19314, 2933, UINT16_MAX, 2933, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1502, 2934, UINT16_MAX, 2934, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 2812, 2935, UINT16_MAX, 2935, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1494, 2936, UINT16_MAX, 2936, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1503, 2937, UINT16_MAX, 2937, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8, UINT16_MAX, 8873, UINT16_MAX, 8873, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 11130, UINT16_MAX, 8874, UINT16_MAX, 8874, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19324, UINT16_MAX, 8875, UINT16_MAX, 8875, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 11135, UINT16_MAX, 8876, UINT16_MAX, 8876, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21, UINT16_MAX, 8877, UINT16_MAX, 8877, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 11137, UINT16_MAX, 8878, UINT16_MAX, 8878, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19331, UINT16_MAX, 8879, UINT16_MAX, 8879, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 27526, UINT16_MAX, 8880, UINT16_MAX, 8880, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 11146, UINT16_MAX, 8881, UINT16_MAX, 8881, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23, UINT16_MAX, 8882, UINT16_MAX, 8882, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 11148, UINT16_MAX, 8883, UINT16_MAX, 8883, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19342, UINT16_MAX, 8884, UINT16_MAX, 8884, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 11, UINT16_MAX, 8885, UINT16_MAX, 8885, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 2, UINT16_MAX, 8886, UINT16_MAX, 8886, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3, UINT16_MAX, 8887, UINT16_MAX, 8887, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12, UINT16_MAX, 8888, UINT16_MAX, 8888, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2961, UINT16_MAX, 2961, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8889, UINT16_MAX, 8889, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 19346, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5039, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5042, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5045, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11157, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11159, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11161, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11163, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11165, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11167, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5048, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5054, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5051, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5057, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11169, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5060, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11171, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5063, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11173, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5066, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11175, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5069, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11177, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 11179, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19373, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 11184, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19378, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5072, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5075, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11191, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5078, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11193, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5081, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11195, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5090, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11197, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5087, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11199, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5099, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5102, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11201, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11203, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11205, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11207, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11209, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5105, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5108, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11211, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11213, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5111, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5114, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11215, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11217, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5117, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5120, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5147, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5150, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11219, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11221, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5123, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5126, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11223, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11225, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5129, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5132, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11227, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11229, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5153, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5156, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5135, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5138, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5141, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5144, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11231, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11233, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11235, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11237, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5159, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5162, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5165, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5168, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11239, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11241, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11243, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11245, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11247, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11249, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11251, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11253, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, 0, 3063, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, 0, 3064, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 38, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 31, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 32, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 2793, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 2794, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 2795, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 2796, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 2797, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 2798, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 11257, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 11259, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 11261, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 11263, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 11265, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 11267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 11269, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 11271, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 11273, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 11275, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 11277, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19471, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19474, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19477, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19480, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19483, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19486, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19489, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19492, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19495, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 27690, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 27694, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 27698, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 27702, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 27706, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 27710, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 27714, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 27718, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 27722, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 27726, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 27730, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 11350, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 11352, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 11354, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 11356, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 11358, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 11360, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 11362, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 11364, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 11366, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 19560, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 19563, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 19566, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 19569, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 19572, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 19575, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 19578, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 19581, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 19584, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 19587, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 19590, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19593, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19596, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19599, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19602, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19605, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19608, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19611, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19614, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19617, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19620, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19623, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19626, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19629, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19632, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19635, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19638, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19641, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19644, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19647, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19650, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19653, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19656, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19659, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19662, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19665, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19668, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1491, 3287, UINT16_MAX, 3287, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1493, 3288, UINT16_MAX, 3288, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 2812, 3289, UINT16_MAX, 3289, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1494, 3290, UINT16_MAX, 3290, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1495, 3291, UINT16_MAX, 3291, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 2837, 3292, UINT16_MAX, 3292, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1497, 3293, UINT16_MAX, 3293, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1498, 3294, UINT16_MAX, 3294, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1499, 3295, UINT16_MAX, 3295, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1500, 3296, UINT16_MAX, 3296, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1501, 3297, UINT16_MAX, 3297, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1502, 3298, UINT16_MAX, 3298, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1503, 3299, UINT16_MAX, 3299, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1504, 3300, UINT16_MAX, 3300, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1505, 3301, UINT16_MAX, 3301, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1507, 3302, UINT16_MAX, 3302, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 2826, 3303, UINT16_MAX, 3303, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1508, 3304, UINT16_MAX, 3304, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3305, 3306, UINT16_MAX, 3306, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1509, 3307, UINT16_MAX, 3307, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1510, 3308, UINT16_MAX, 3308, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 2908, 3309, UINT16_MAX, 3309, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1511, 3310, UINT16_MAX, 3310, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 2925, 3311, UINT16_MAX, 3311, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3312, 3313, UINT16_MAX, 3313, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 2834, 3314, UINT16_MAX, 3314, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 0, UINT16_MAX, 8890, UINT16_MAX, 8890, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1, UINT16_MAX, 8891, UINT16_MAX, 8891, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 2, UINT16_MAX, 8892, UINT16_MAX, 8892, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3, UINT16_MAX, 8893, UINT16_MAX, 8893, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4, UINT16_MAX, 8894, UINT16_MAX, 8894, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5, UINT16_MAX, 8895, UINT16_MAX, 8895, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 6, UINT16_MAX, 8896, UINT16_MAX, 8896, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 7, UINT16_MAX, 8897, UINT16_MAX, 8897, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 8, UINT16_MAX, 8898, UINT16_MAX, 8898, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 9, UINT16_MAX, 8899, UINT16_MAX, 8899, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 10, UINT16_MAX, 8900, UINT16_MAX, 8900, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 11, UINT16_MAX, 8901, UINT16_MAX, 8901, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12, UINT16_MAX, 8902, UINT16_MAX, 8902, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 13, UINT16_MAX, 8903, UINT16_MAX, 8903, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 14, UINT16_MAX, 8904, UINT16_MAX, 8904, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 15, UINT16_MAX, 8905, UINT16_MAX, 8905, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 16, UINT16_MAX, 8906, UINT16_MAX, 8906, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 17, UINT16_MAX, 8907, UINT16_MAX, 8907, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 18, UINT16_MAX, 8908, UINT16_MAX, 8908, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 19, UINT16_MAX, 8909, UINT16_MAX, 8909, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 20, UINT16_MAX, 8910, UINT16_MAX, 8910, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21, UINT16_MAX, 8911, UINT16_MAX, 8911, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 22, UINT16_MAX, 8912, UINT16_MAX, 8912, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 23, UINT16_MAX, 8913, UINT16_MAX, 8913, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 24, UINT16_MAX, 8914, UINT16_MAX, 8914, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 25, UINT16_MAX, 8915, UINT16_MAX, 8915, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 2792, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 27891, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19703, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 11514, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19708, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11519, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5171, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3329, UINT16_MAX, 3329, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3330, UINT16_MAX, 3330, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3331, UINT16_MAX, 3331, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3332, UINT16_MAX, 3332, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3333, UINT16_MAX, 3333, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3334, UINT16_MAX, 3334, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3335, UINT16_MAX, 3335, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3336, UINT16_MAX, 3336, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3337, UINT16_MAX, 3337, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3338, UINT16_MAX, 3338, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3339, UINT16_MAX, 3339, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3340, UINT16_MAX, 3340, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3341, UINT16_MAX, 3341, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3342, UINT16_MAX, 3342, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3343, UINT16_MAX, 3343, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3344, UINT16_MAX, 3344, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3345, UINT16_MAX, 3345, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3346, UINT16_MAX, 3346, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3347, UINT16_MAX, 3347, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3348, UINT16_MAX, 3348, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3349, UINT16_MAX, 3349, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3350, UINT16_MAX, 3350, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3351, UINT16_MAX, 3351, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3352, UINT16_MAX, 3352, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3353, UINT16_MAX, 3353, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3354, UINT16_MAX, 3354, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3355, UINT16_MAX, 3355, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3356, UINT16_MAX, 3356, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3357, UINT16_MAX, 3357, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3358, UINT16_MAX, 3358, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3359, UINT16_MAX, 3359, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3360, UINT16_MAX, 3360, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3361, UINT16_MAX, 3361, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3362, UINT16_MAX, 3362, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3363, UINT16_MAX, 3363, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3364, UINT16_MAX, 3364, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3365, UINT16_MAX, 3365, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3366, UINT16_MAX, 3366, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3367, UINT16_MAX, 3367, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3368, UINT16_MAX, 3368, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3369, UINT16_MAX, 3369, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3370, UINT16_MAX, 3370, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3371, UINT16_MAX, 3371, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3372, UINT16_MAX, 3372, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3373, UINT16_MAX, 3373, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3374, UINT16_MAX, 3374, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3375, UINT16_MAX, 3375, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8916, UINT16_MAX, 8916, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8917, UINT16_MAX, 8917, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8918, UINT16_MAX, 8918, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8919, UINT16_MAX, 8919, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8920, UINT16_MAX, 8920, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8921, UINT16_MAX, 8921, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8922, UINT16_MAX, 8922, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8923, UINT16_MAX, 8923, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8924, UINT16_MAX, 8924, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8925, UINT16_MAX, 8925, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8926, UINT16_MAX, 8926, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8927, UINT16_MAX, 8927, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8928, UINT16_MAX, 8928, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8929, UINT16_MAX, 8929, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8930, UINT16_MAX, 8930, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8931, UINT16_MAX, 8931, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8932, UINT16_MAX, 8932, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8933, UINT16_MAX, 8933, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8934, UINT16_MAX, 8934, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8935, UINT16_MAX, 8935, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8936, UINT16_MAX, 8936, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8937, UINT16_MAX, 8937, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8938, UINT16_MAX, 8938, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8939, UINT16_MAX, 8939, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8940, UINT16_MAX, 8940, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8941, UINT16_MAX, 8941, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8942, UINT16_MAX, 8942, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8943, UINT16_MAX, 8943, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8944, UINT16_MAX, 8944, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8945, UINT16_MAX, 8945, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8946, UINT16_MAX, 8946, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8947, UINT16_MAX, 8947, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8948, UINT16_MAX, 8948, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8949, UINT16_MAX, 8949, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8950, UINT16_MAX, 8950, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8951, UINT16_MAX, 8951, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8952, UINT16_MAX, 8952, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8953, UINT16_MAX, 8953, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8954, UINT16_MAX, 8954, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8955, UINT16_MAX, 8955, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8956, UINT16_MAX, 8956, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8957, UINT16_MAX, 8957, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8958, UINT16_MAX, 8958, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8959, UINT16_MAX, 8959, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8960, UINT16_MAX, 8960, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8961, UINT16_MAX, 8961, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8962, UINT16_MAX, 8962, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3376, UINT16_MAX, 3376, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8963, UINT16_MAX, 8963, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3377, UINT16_MAX, 3377, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3378, UINT16_MAX, 3378, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3379, UINT16_MAX, 3379, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8964, UINT16_MAX, 8964, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8965, UINT16_MAX, 8965, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3380, UINT16_MAX, 3380, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8966, UINT16_MAX, 8966, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3381, UINT16_MAX, 3381, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8967, UINT16_MAX, 8967, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3382, UINT16_MAX, 3382, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8968, UINT16_MAX, 8968, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1513, UINT16_MAX, 1513, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1531, UINT16_MAX, 1531, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1512, UINT16_MAX, 1512, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1520, UINT16_MAX, 1520, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3383, UINT16_MAX, 3383, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8969, UINT16_MAX, 8969, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3384, UINT16_MAX, 3384, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8970, UINT16_MAX, 8970, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 9, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2908, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3385, UINT16_MAX, 3385, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3386, UINT16_MAX, 3386, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3387, UINT16_MAX, 3387, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8971, UINT16_MAX, 8971, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3388, UINT16_MAX, 3388, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8972, UINT16_MAX, 8972, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3389, UINT16_MAX, 3389, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8973, UINT16_MAX, 8973, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3390, UINT16_MAX, 3390, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8974, UINT16_MAX, 8974, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3391, UINT16_MAX, 3391, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8975, UINT16_MAX, 8975, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3392, UINT16_MAX, 3392, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8976, UINT16_MAX, 8976, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3393, UINT16_MAX, 3393, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8977, UINT16_MAX, 8977, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3394, UINT16_MAX, 3394, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8978, UINT16_MAX, 8978, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3395, UINT16_MAX, 3395, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8979, UINT16_MAX, 8979, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3396, UINT16_MAX, 3396, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8980, UINT16_MAX, 8980, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3397, UINT16_MAX, 3397, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8981, UINT16_MAX, 8981, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3398, UINT16_MAX, 3398, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8982, UINT16_MAX, 8982, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3399, UINT16_MAX, 3399, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8983, UINT16_MAX, 8983, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3400, UINT16_MAX, 3400, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8984, UINT16_MAX, 8984, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3401, UINT16_MAX, 3401, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8985, UINT16_MAX, 8985, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3402, UINT16_MAX, 3402, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8986, UINT16_MAX, 8986, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3403, UINT16_MAX, 3403, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8987, UINT16_MAX, 8987, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3404, UINT16_MAX, 3404, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8988, UINT16_MAX, 8988, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3405, UINT16_MAX, 3405, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8989, UINT16_MAX, 8989, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3406, UINT16_MAX, 3406, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8990, UINT16_MAX, 8990, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3407, UINT16_MAX, 3407, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8991, UINT16_MAX, 8991, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3408, UINT16_MAX, 3408, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8992, UINT16_MAX, 8992, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3409, UINT16_MAX, 3409, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8993, UINT16_MAX, 8993, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3410, UINT16_MAX, 3410, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8994, UINT16_MAX, 8994, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3411, UINT16_MAX, 3411, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8995, UINT16_MAX, 8995, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3412, UINT16_MAX, 3412, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8996, UINT16_MAX, 8996, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3413, UINT16_MAX, 3413, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8997, UINT16_MAX, 8997, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3414, UINT16_MAX, 3414, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8998, UINT16_MAX, 8998, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3415, UINT16_MAX, 3415, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8999, UINT16_MAX, 8999, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3416, UINT16_MAX, 3416, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9000, UINT16_MAX, 9000, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3417, UINT16_MAX, 3417, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9001, UINT16_MAX, 9001, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3418, UINT16_MAX, 3418, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9002, UINT16_MAX, 9002, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3419, UINT16_MAX, 3419, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9003, UINT16_MAX, 9003, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3420, UINT16_MAX, 3420, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9004, UINT16_MAX, 9004, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3421, UINT16_MAX, 3421, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9005, UINT16_MAX, 9005, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3422, UINT16_MAX, 3422, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9006, UINT16_MAX, 9006, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3423, UINT16_MAX, 3423, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9007, UINT16_MAX, 9007, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3424, UINT16_MAX, 3424, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9008, UINT16_MAX, 9008, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3425, UINT16_MAX, 3425, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9009, UINT16_MAX, 9009, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3426, UINT16_MAX, 3426, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9010, UINT16_MAX, 9010, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3427, UINT16_MAX, 3427, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9011, UINT16_MAX, 9011, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3428, UINT16_MAX, 3428, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9012, UINT16_MAX, 9012, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3429, UINT16_MAX, 3429, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9013, UINT16_MAX, 9013, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3430, UINT16_MAX, 3430, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9014, UINT16_MAX, 9014, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3431, UINT16_MAX, 3431, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9015, UINT16_MAX, 9015, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3432, UINT16_MAX, 3432, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9016, UINT16_MAX, 9016, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3433, UINT16_MAX, 3433, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9017, UINT16_MAX, 9017, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3434, UINT16_MAX, 3434, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9018, UINT16_MAX, 9018, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3435, UINT16_MAX, 3435, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9019, UINT16_MAX, 9019, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3436, UINT16_MAX, 3436, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9020, UINT16_MAX, 9020, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3437, UINT16_MAX, 3437, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9021, UINT16_MAX, 9021, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3438, UINT16_MAX, 3438, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9022, UINT16_MAX, 9022, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3439, UINT16_MAX, 3439, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9023, UINT16_MAX, 9023, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9024, UINT16_MAX, 9024, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9025, UINT16_MAX, 9025, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9026, UINT16_MAX, 9026, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9027, UINT16_MAX, 9027, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9028, UINT16_MAX, 9028, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9029, UINT16_MAX, 9029, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9030, UINT16_MAX, 9030, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9031, UINT16_MAX, 9031, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9032, UINT16_MAX, 9032, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9033, UINT16_MAX, 9033, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9034, UINT16_MAX, 9034, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9035, UINT16_MAX, 9035, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9036, UINT16_MAX, 9036, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9037, UINT16_MAX, 9037, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9038, UINT16_MAX, 9038, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9039, UINT16_MAX, 9039, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9040, UINT16_MAX, 9040, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9041, UINT16_MAX, 9041, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9042, UINT16_MAX, 9042, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9043, UINT16_MAX, 9043, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9044, UINT16_MAX, 9044, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9045, UINT16_MAX, 9045, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9046, UINT16_MAX, 9046, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9047, UINT16_MAX, 9047, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9048, UINT16_MAX, 9048, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9049, UINT16_MAX, 9049, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9050, UINT16_MAX, 9050, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9051, UINT16_MAX, 9051, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9052, UINT16_MAX, 9052, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9053, UINT16_MAX, 9053, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9054, UINT16_MAX, 9054, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9055, UINT16_MAX, 9055, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9056, UINT16_MAX, 9056, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9057, UINT16_MAX, 9057, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9058, UINT16_MAX, 9058, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9059, UINT16_MAX, 9059, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9060, UINT16_MAX, 9060, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9061, UINT16_MAX, 9061, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9062, UINT16_MAX, 9062, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9063, UINT16_MAX, 9063, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3440, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3441, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3442, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3443, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3444, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3445, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3446, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3447, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3448, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3449, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3450, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3451, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3452, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3453, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3454, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3455, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3456, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3457, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3458, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3459, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3460, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3461, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3462, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3463, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3464, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3465, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3466, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3467, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3468, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3469, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3470, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3471, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3472, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3473, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3474, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3475, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3476, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3477, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3478, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3479, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3480, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3481, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3482, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3483, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3484, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3485, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3486, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3487, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3488, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3489, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3490, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3491, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3492, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3493, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3494, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3495, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3496, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3497, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3498, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3499, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3500, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3501, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3502, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3503, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3504, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3505, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3506, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3507, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3508, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3509, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3510, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3511, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3512, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3513, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3514, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3515, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3516, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3517, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3518, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3519, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3520, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3521, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3522, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3523, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3524, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3525, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3526, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3527, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3528, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3529, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3530, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3531, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3532, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3533, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3534, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3535, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3536, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3537, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3538, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3539, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3540, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3541, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3542, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3543, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3544, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3545, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3546, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3547, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3548, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3549, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3550, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3551, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3552, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3553, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3554, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3555, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3556, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3557, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3558, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3559, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3560, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3561, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3562, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3563, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3564, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3565, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3566, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3567, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3568, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3569, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3570, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3571, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3572, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3573, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3574, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3575, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3576, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3577, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3578, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3579, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3580, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3581, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3582, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3583, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3584, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3585, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3586, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3587, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3588, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3589, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3590, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3591, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3592, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3593, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3594, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3595, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3596, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3597, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3598, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3599, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3601, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3602, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3603, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3604, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3605, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3606, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3607, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3608, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3609, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3610, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3611, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3612, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3613, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3614, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3615, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3616, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3617, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3618, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3619, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3620, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3621, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3622, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3623, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3624, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3625, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3626, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3627, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3628, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3629, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3630, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3631, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3632, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3633, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3634, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3635, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3636, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3637, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3638, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3639, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3640, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3641, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3642, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3643, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3644, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3645, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3646, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3647, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3648, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3649, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3650, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3651, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3652, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3653, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3654, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3655, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3656, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_ZS, 0, UTF8PROC_BIDI_CLASS_WS, UTF8PROC_DECOMP_TYPE_WIDE, 26, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_MN, 218, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MC, 224, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3657, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3466, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3658, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3659, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5239, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5174, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11852, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5177, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11854, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5180, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11856, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5183, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11858, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5186, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11860, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5189, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11862, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5192, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11864, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5195, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11866, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5198, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11868, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5201, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11870, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5204, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11872, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5207, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11874, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5210, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11876, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5213, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11878, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5216, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11880, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5219, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11882, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11884, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5223, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11886, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11888, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5227, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11890, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11892, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5231, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11894, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11896, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5235, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11898, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11900, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11902, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_MN, 8, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32820, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 8, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32821, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 11904, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 11906, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5242, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, 11908, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_VERTICAL, 11910, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5310, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5245, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11912, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5248, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11914, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5251, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11916, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5254, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11918, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5257, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11920, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5260, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11922, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5263, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11924, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5266, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11926, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5269, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11928, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5272, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11930, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5275, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11932, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5278, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11934, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5281, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11936, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5284, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11938, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5287, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11940, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5290, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11942, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11944, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5294, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11946, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11948, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5298, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11950, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11952, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5302, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11954, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11956, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5306, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11958, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11960, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5313, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5316, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5319, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5322, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11962, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11964, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11966, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11968, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11970, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5325, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, 11972, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_VERTICAL, 11974, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3784, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3785, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3786, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3787, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3788, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3789, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3790, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3791, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3792, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3793, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3794, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3795, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3796, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3797, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3798, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3799, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3800, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3802, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3803, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3804, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3805, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3806, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3807, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3808, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3809, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3810, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3811, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3812, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3813, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3814, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3815, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3816, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3817, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3818, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3819, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3820, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3821, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3822, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3823, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3824, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3825, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3826, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3827, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3828, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3829, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3830, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3831, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3832, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3833, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3834, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3835, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3836, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3837, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3838, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3839, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3840, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3841, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3842, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3843, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3844, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3845, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3846, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3847, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3848, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3849, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3850, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3851, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3852, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3853, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3854, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3855, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3856, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3857, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3858, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3859, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3860, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3861, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3862, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3863, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3864, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3865, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3866, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3867, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3868, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3869, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3870, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3871, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3872, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3873, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3874, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3875, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3876, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3877, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3443, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3449, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3878, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3879, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3880, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3881, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3882, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3883, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3447, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3884, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3885, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3886, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3887, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3451, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20272, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20275, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20278, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20281, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20284, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20287, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20290, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20293, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20296, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20299, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20302, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20305, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20308, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20311, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28506, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28510, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28514, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28518, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28522, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28526, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28530, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28534, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28538, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28542, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28546, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28550, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28554, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28558, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28562, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 53142, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 44957, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20387, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20390, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20393, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20396, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20399, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20402, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20405, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20408, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20411, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20414, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20417, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20420, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20423, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20426, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20429, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20432, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20435, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20438, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20441, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20444, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20447, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20450, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20453, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20456, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20459, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20462, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20465, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20468, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20471, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20474, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20477, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20480, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20483, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20486, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20489, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20492, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4111, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4112, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3509, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4113, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 20498, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12309, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12311, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12313, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12315, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12317, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12319, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12321, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12323, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12325, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12327, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12329, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12331, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12333, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12335, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12337, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3784, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3787, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3790, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3792, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3800, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3804, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3806, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3807, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3809, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3810, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3811, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3812, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3813, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12339, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12341, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12343, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12345, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12347, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12349, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12351, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12353, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12355, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12357, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12359, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12361, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12363, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12365, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 36943, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 28756, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12376, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3443, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3449, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3878, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3879, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4186, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4187, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4188, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3454, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3466, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3516, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3528, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3527, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3517, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3609, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3474, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3514, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4190, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4191, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4192, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4193, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4194, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4195, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4196, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4197, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4198, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4199, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3480, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4200, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4201, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4202, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4203, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4204, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4205, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4206, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4207, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3880, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3881, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3882, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4208, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4209, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4210, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4211, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4212, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4213, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4214, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4215, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4216, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4217, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12410, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12412, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12414, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12416, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12418, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12420, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12422, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12424, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12426, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12428, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12430, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12432, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12434, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12436, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12438, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12440, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12442, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12444, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12446, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12448, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12450, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12452, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12454, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12456, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20650, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20653, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20656, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 12467, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 20661, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 12472, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 20666, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4285, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4286, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4287, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4288, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4289, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4290, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4291, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4292, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4293, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4294, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4295, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4296, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4297, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4298, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4299, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4300, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4301, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4302, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4303, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4304, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4305, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4306, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4307, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4308, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4309, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4310, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4311, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4312, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4313, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4314, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4315, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4316, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4317, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4318, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4319, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4320, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4321, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4322, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4323, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4324, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4325, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4326, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4327, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4328, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4329, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4330, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4331, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12524, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28910, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28914, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28918, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20730, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28925, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20737, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20740, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37127, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28940, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20752, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20755, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20758, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28953, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28957, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20769, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20772, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12583, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20777, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28972, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28976, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12596, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37174, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 45371, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37185, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20806, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37193, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37198, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29011, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20823, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20826, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20829, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29024, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37220, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29033, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20845, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20848, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20851, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12662, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12664, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12666, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12668, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20862, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20865, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37252, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20873, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29068, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37264, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20885, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12696, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12698, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29089, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37285, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20906, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37293, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12722, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20916, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20919, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20922, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20925, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20928, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29123, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20935, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12746, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20940, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20943, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20946, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29141, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20953, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20956, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20959, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37346, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29159, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12779, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37357, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12786, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29172, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29176, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20988, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20991, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20994, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12809, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21003, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29198, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12818, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37396, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21017, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12828, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12830, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12832, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12834, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12836, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12838, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12840, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12842, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12844, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12846, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21040, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21043, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21046, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21049, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21052, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21055, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21058, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21061, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21064, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21067, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21070, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21073, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21076, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21079, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21082, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21085, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12896, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12898, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21092, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12903, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12905, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 12907, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 21101, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 21104, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 12915, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12917, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12919, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12921, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12923, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29309, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12929, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12931, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12933, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12935, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12937, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12939, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12941, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12943, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21137, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29332, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12952, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12954, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12956, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12958, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12960, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12962, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12964, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21158, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21161, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21164, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21167, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12978, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12980, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12982, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12984, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12986, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12988, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12990, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12992, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12994, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12996, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21190, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21193, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13004, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21198, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21201, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21204, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13015, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21209, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21212, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29407, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13027, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21221, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21224, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21227, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21230, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37617, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 45814, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13052, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13054, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13056, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13058, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13060, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13062, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13064, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13066, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13068, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13070, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13072, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13074, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13076, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13078, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13080, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13082, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13084, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13086, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29472, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13092, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13094, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13096, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29482, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21294, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13105, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13107, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13109, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13111, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13113, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13115, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13117, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13119, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13121, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13123, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21317, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13128, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13130, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21324, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21327, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13138, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29524, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21336, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13147, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13149, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13151, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13153, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 21347, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 21350, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13161, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13163, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13165, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13167, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13169, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13171, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13173, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13175, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13177, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21371, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21374, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21377, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21380, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21383, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21386, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21389, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21392, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21395, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21398, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21401, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21404, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21407, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21410, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21413, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21416, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21419, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21422, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21425, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21428, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21431, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21434, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 21437, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5056, UINT16_MAX, 5056, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9064, UINT16_MAX, 9064, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5057, UINT16_MAX, 5057, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9065, UINT16_MAX, 9065, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5058, UINT16_MAX, 5058, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9066, UINT16_MAX, 9066, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5059, UINT16_MAX, 5059, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9067, UINT16_MAX, 9067, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5060, UINT16_MAX, 5060, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9068, UINT16_MAX, 9068, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1445, UINT16_MAX, 1445, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8621, UINT16_MAX, 8621, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5061, UINT16_MAX, 5061, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9069, UINT16_MAX, 9069, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5062, UINT16_MAX, 5062, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9070, UINT16_MAX, 9070, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5063, UINT16_MAX, 5063, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9071, UINT16_MAX, 9071, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5064, UINT16_MAX, 5064, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9072, UINT16_MAX, 9072, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5065, UINT16_MAX, 5065, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9073, UINT16_MAX, 9073, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5066, UINT16_MAX, 5066, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9074, UINT16_MAX, 9074, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5067, UINT16_MAX, 5067, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9075, UINT16_MAX, 9075, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5068, UINT16_MAX, 5068, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9076, UINT16_MAX, 9076, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5069, UINT16_MAX, 5069, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9077, UINT16_MAX, 9077, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5070, UINT16_MAX, 5070, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9078, UINT16_MAX, 9078, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5071, UINT16_MAX, 5071, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9079, UINT16_MAX, 9079, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5072, UINT16_MAX, 5072, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9080, UINT16_MAX, 9080, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5073, UINT16_MAX, 5073, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9081, UINT16_MAX, 9081, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5074, UINT16_MAX, 5074, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9082, UINT16_MAX, 9082, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5075, UINT16_MAX, 5075, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9083, UINT16_MAX, 9083, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5076, UINT16_MAX, 5076, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9084, UINT16_MAX, 9084, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5077, UINT16_MAX, 5077, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9085, UINT16_MAX, 9085, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5078, UINT16_MAX, 5078, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9086, UINT16_MAX, 9086, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5079, UINT16_MAX, 5079, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9087, UINT16_MAX, 9087, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5080, UINT16_MAX, 5080, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9088, UINT16_MAX, 9088, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5081, UINT16_MAX, 5081, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9089, UINT16_MAX, 9089, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5082, UINT16_MAX, 5082, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9090, UINT16_MAX, 9090, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5083, UINT16_MAX, 5083, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9091, UINT16_MAX, 9091, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5084, UINT16_MAX, 5084, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9092, UINT16_MAX, 9092, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5085, UINT16_MAX, 5085, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9093, UINT16_MAX, 9093, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5086, UINT16_MAX, 5086, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9094, UINT16_MAX, 9094, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5087, UINT16_MAX, 5087, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9095, UINT16_MAX, 9095, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5088, UINT16_MAX, 5088, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9096, UINT16_MAX, 9096, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5089, UINT16_MAX, 5089, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9097, UINT16_MAX, 9097, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5090, UINT16_MAX, 5090, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9098, UINT16_MAX, 9098, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5091, UINT16_MAX, 5091, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9099, UINT16_MAX, 9099, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 981, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 983, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5092, UINT16_MAX, 5092, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9100, UINT16_MAX, 9100, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5093, UINT16_MAX, 5093, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9101, UINT16_MAX, 9101, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5094, UINT16_MAX, 5094, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9102, UINT16_MAX, 9102, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5095, UINT16_MAX, 5095, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9103, UINT16_MAX, 9103, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5096, UINT16_MAX, 5096, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9104, UINT16_MAX, 9104, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5097, UINT16_MAX, 5097, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9105, UINT16_MAX, 9105, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5098, UINT16_MAX, 5098, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9106, UINT16_MAX, 9106, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5099, UINT16_MAX, 5099, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9107, UINT16_MAX, 9107, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5100, UINT16_MAX, 5100, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9108, UINT16_MAX, 9108, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5101, UINT16_MAX, 5101, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9109, UINT16_MAX, 9109, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5102, UINT16_MAX, 5102, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9110, UINT16_MAX, 9110, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5103, UINT16_MAX, 5103, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9111, UINT16_MAX, 9111, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5104, UINT16_MAX, 5104, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9112, UINT16_MAX, 9112, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5105, UINT16_MAX, 5105, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9113, UINT16_MAX, 9113, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5106, UINT16_MAX, 5106, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9114, UINT16_MAX, 9114, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5107, UINT16_MAX, 5107, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9115, UINT16_MAX, 9115, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5108, UINT16_MAX, 5108, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9116, UINT16_MAX, 9116, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5109, UINT16_MAX, 5109, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9117, UINT16_MAX, 9117, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5110, UINT16_MAX, 5110, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9118, UINT16_MAX, 9118, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5111, UINT16_MAX, 5111, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9119, UINT16_MAX, 9119, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5112, UINT16_MAX, 5112, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9120, UINT16_MAX, 9120, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5113, UINT16_MAX, 5113, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9121, UINT16_MAX, 9121, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5114, UINT16_MAX, 5114, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9122, UINT16_MAX, 9122, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5115, UINT16_MAX, 5115, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9123, UINT16_MAX, 9123, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5116, UINT16_MAX, 5116, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9124, UINT16_MAX, 9124, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5117, UINT16_MAX, 5117, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9125, UINT16_MAX, 9125, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5118, UINT16_MAX, 5118, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9126, UINT16_MAX, 9126, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5119, UINT16_MAX, 5119, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9127, UINT16_MAX, 9127, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5120, UINT16_MAX, 5120, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9128, UINT16_MAX, 9128, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5121, UINT16_MAX, 5121, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9129, UINT16_MAX, 9129, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5122, UINT16_MAX, 5122, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9130, UINT16_MAX, 9130, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5123, UINT16_MAX, 5123, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9131, UINT16_MAX, 9131, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5124, UINT16_MAX, 5124, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9132, UINT16_MAX, 9132, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5125, UINT16_MAX, 5125, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9133, UINT16_MAX, 9133, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5126, UINT16_MAX, 5126, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9134, UINT16_MAX, 9134, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5127, UINT16_MAX, 5127, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9135, UINT16_MAX, 9135, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5128, UINT16_MAX, 5128, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9136, UINT16_MAX, 9136, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5129, UINT16_MAX, 5129, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9137, UINT16_MAX, 9137, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5129, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5130, UINT16_MAX, 5130, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9138, UINT16_MAX, 9138, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5131, UINT16_MAX, 5131, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9139, UINT16_MAX, 9139, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5132, UINT16_MAX, 5132, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5133, UINT16_MAX, 5133, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9140, UINT16_MAX, 9140, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5134, UINT16_MAX, 5134, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9141, UINT16_MAX, 9141, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5135, UINT16_MAX, 5135, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9142, UINT16_MAX, 9142, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5136, UINT16_MAX, 5136, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9143, UINT16_MAX, 9143, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5137, UINT16_MAX, 5137, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9144, UINT16_MAX, 9144, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5138, UINT16_MAX, 5138, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9145, UINT16_MAX, 9145, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1524, UINT16_MAX, 1524, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5139, UINT16_MAX, 5139, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9146, UINT16_MAX, 9146, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5140, UINT16_MAX, 5140, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9147, UINT16_MAX, 9147, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9148, UINT16_MAX, 9148, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5141, UINT16_MAX, 5141, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9149, UINT16_MAX, 9149, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5142, UINT16_MAX, 5142, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9150, UINT16_MAX, 9150, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5143, UINT16_MAX, 5143, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9151, UINT16_MAX, 9151, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5144, UINT16_MAX, 5144, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9152, UINT16_MAX, 9152, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5145, UINT16_MAX, 5145, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9153, UINT16_MAX, 9153, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5146, UINT16_MAX, 5146, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9154, UINT16_MAX, 9154, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5147, UINT16_MAX, 5147, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9155, UINT16_MAX, 9155, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5148, UINT16_MAX, 5148, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9156, UINT16_MAX, 9156, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5149, UINT16_MAX, 5149, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9157, UINT16_MAX, 9157, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5150, UINT16_MAX, 5150, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9158, UINT16_MAX, 9158, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 785, UINT16_MAX, 785, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1515, UINT16_MAX, 1515, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1523, UINT16_MAX, 1523, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5151, UINT16_MAX, 5151, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1525, UINT16_MAX, 1525, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5152, UINT16_MAX, 5152, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5153, UINT16_MAX, 5153, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1527, UINT16_MAX, 1527, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5154, UINT16_MAX, 5154, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5155, UINT16_MAX, 5155, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9159, UINT16_MAX, 9159, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5156, UINT16_MAX, 5156, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9160, UINT16_MAX, 9160, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5157, UINT16_MAX, 5157, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9161, UINT16_MAX, 9161, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5158, UINT16_MAX, 5158, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9162, UINT16_MAX, 9162, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5159, UINT16_MAX, 5159, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9163, UINT16_MAX, 9163, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5160, UINT16_MAX, 5160, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9164, UINT16_MAX, 9164, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5161, UINT16_MAX, 5161, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9165, UINT16_MAX, 9165, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5162, UINT16_MAX, 5162, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1536, UINT16_MAX, 1536, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5163, UINT16_MAX, 5163, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5164, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 371, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9166, UINT16_MAX, 9166, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5094, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5165, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3377, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5166, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5167, 5167, UINT16_MAX, 5167, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5168, 5168, UINT16_MAX, 5168, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5169, 5169, UINT16_MAX, 5169, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5170, 5170, UINT16_MAX, 5170, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5171, 5171, UINT16_MAX, 5171, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5172, 5172, UINT16_MAX, 5172, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5173, 5173, UINT16_MAX, 5173, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5174, 5174, UINT16_MAX, 5174, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5175, 5175, UINT16_MAX, 5175, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5176, 5176, UINT16_MAX, 5176, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5177, 5177, UINT16_MAX, 5177, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5178, 5178, UINT16_MAX, 5178, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5179, 5179, UINT16_MAX, 5179, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5180, 5180, UINT16_MAX, 5180, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5181, 5181, UINT16_MAX, 5181, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5182, 5182, UINT16_MAX, 5182, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5183, 5183, UINT16_MAX, 5183, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5184, 5184, UINT16_MAX, 5184, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5185, 5185, UINT16_MAX, 5185, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5186, 5186, UINT16_MAX, 5186, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5187, 5187, UINT16_MAX, 5187, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5188, 5188, UINT16_MAX, 5188, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5189, 5189, UINT16_MAX, 5189, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5190, 5190, UINT16_MAX, 5190, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5191, 5191, UINT16_MAX, 5191, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5192, 5192, UINT16_MAX, 5192, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5193, 5193, UINT16_MAX, 5193, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5194, 5194, UINT16_MAX, 5194, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5195, 5195, UINT16_MAX, 5195, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5196, 5196, UINT16_MAX, 5196, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5197, 5197, UINT16_MAX, 5197, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5198, 5198, UINT16_MAX, 5198, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5199, 5199, UINT16_MAX, 5199, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5200, 5200, UINT16_MAX, 5200, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5201, 5201, UINT16_MAX, 5201, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5202, 5202, UINT16_MAX, 5202, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5203, 5203, UINT16_MAX, 5203, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5204, 5204, UINT16_MAX, 5204, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5205, 5205, UINT16_MAX, 5205, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5206, 5206, UINT16_MAX, 5206, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5207, 5207, UINT16_MAX, 5207, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5208, 5208, UINT16_MAX, 5208, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5209, 5209, UINT16_MAX, 5209, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5210, 5210, UINT16_MAX, 5210, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5211, 5211, UINT16_MAX, 5211, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5212, 5212, UINT16_MAX, 5212, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5213, 5213, UINT16_MAX, 5213, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5214, 5214, UINT16_MAX, 5214, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5215, 5215, UINT16_MAX, 5215, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5216, 5216, UINT16_MAX, 5216, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5217, 5217, UINT16_MAX, 5217, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5218, 5218, UINT16_MAX, 5218, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5219, 5219, UINT16_MAX, 5219, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5220, 5220, UINT16_MAX, 5220, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5221, 5221, UINT16_MAX, 5221, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5222, 5222, UINT16_MAX, 5222, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5223, 5223, UINT16_MAX, 5223, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5224, 5224, UINT16_MAX, 5224, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5225, 5225, UINT16_MAX, 5225, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5226, 5226, UINT16_MAX, 5226, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5227, 5227, UINT16_MAX, 5227, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5228, 5228, UINT16_MAX, 5228, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5229, 5229, UINT16_MAX, 5229, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5230, 5230, UINT16_MAX, 5230, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5231, 5231, UINT16_MAX, 5231, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5232, 5232, UINT16_MAX, 5232, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5233, 5233, UINT16_MAX, 5233, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5234, 5234, UINT16_MAX, 5234, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5235, 5235, UINT16_MAX, 5235, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5236, 5236, UINT16_MAX, 5236, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5237, 5237, UINT16_MAX, 5237, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5238, 5238, UINT16_MAX, 5238, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5239, 5239, UINT16_MAX, 5239, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5240, 5240, UINT16_MAX, 5240, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5241, 5241, UINT16_MAX, 5241, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5242, 5242, UINT16_MAX, 5242, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5243, 5243, UINT16_MAX, 5243, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5244, 5244, UINT16_MAX, 5244, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5245, 5245, UINT16_MAX, 5245, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5246, 5246, UINT16_MAX, 5246, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_LV}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_LVT}, - {UTF8PROC_CATEGORY_CS, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_CO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5247, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5248, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3601, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5249, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5250, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5251, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5252, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3655, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5253, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3609, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5254, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5255, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5256, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5257, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5258, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5259, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5260, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5261, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5262, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5263, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5264, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5265, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5266, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5268, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5269, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5270, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5271, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5272, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5273, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5274, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5275, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5277, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5278, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5279, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5280, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5281, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5282, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5283, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5284, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5285, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5286, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5287, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5288, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5289, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5290, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5291, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5292, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5293, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5294, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3567, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5295, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5296, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5297, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5298, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5299, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5300, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5301, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5302, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5303, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5304, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5305, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3640, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5306, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5307, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5308, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5309, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5310, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5311, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5312, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5313, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5314, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5315, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5316, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5317, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5318, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5319, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5320, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5321, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5322, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5323, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5324, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5325, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5326, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5327, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5328, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5329, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5330, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5331, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5332, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5333, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5334, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5335, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5336, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5337, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5338, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5339, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5340, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5341, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5342, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5343, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5344, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5345, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5346, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5347, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5348, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5349, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5350, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5351, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5352, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3603, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5353, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5354, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5355, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5356, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5357, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5358, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5359, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5360, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5361, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5362, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5363, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5364, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5365, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5366, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5367, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3480, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5368, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5369, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5370, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5371, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5372, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5373, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5374, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5375, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3461, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5376, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5377, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5378, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5379, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5380, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5381, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5382, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5383, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5384, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5385, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5386, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5387, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5388, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5389, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5390, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5391, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5392, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5393, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5394, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5395, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5396, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5397, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5398, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5399, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5400, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5401, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5402, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5403, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5404, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5405, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5406, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5407, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5408, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5409, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5410, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5411, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5412, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5413, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5414, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5415, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5416, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5417, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5418, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5419, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5420, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5421, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5422, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5423, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5424, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5425, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5426, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5427, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5428, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5429, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3654, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5430, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5431, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5432, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5433, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5434, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5435, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5436, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5437, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5438, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5439, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5440, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5441, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4187, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5442, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5443, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5444, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5445, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5446, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5447, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5448, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5449, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5450, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5451, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5452, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5453, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5454, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5455, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5456, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5457, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5458, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5459, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5460, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5461, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5462, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5463, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3608, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5464, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5465, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5466, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5467, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5468, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5469, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5470, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5471, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5472, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5473, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5474, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5475, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5476, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3559, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5477, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5478, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5479, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5480, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5481, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5482, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5483, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5484, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5485, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5486, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5487, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5488, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5489, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5490, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5491, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5492, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3586, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5493, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3589, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5494, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5495, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5496, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5497, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5498, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5499, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5500, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5501, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5502, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5503, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5504, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5505, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5506, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5507, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3566, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5508, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5509, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5510, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5511, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5512, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5513, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5514, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5515, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5516, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5517, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5518, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5519, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5520, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5521, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5522, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5523, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5524, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5525, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5526, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5527, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5528, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5529, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3487, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5530, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5531, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5532, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5533, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5534, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5535, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5536, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5537, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5538, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5539, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5540, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5541, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5542, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5543, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5544, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4192, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5545, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5546, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5547, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5548, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4196, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5549, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5550, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5551, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5552, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5553, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5554, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5555, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5556, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5557, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5558, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5559, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5560, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5561, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5562, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5563, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5564, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5565, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5566, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5567, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5568, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5569, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5570, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5571, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5572, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5574, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5575, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5576, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5577, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5578, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5579, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5580, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5581, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5582, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5583, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5584, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5585, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5586, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5587, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5588, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5589, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5590, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5591, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5592, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5593, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5594, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5595, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5596, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5597, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5598, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5599, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5601, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5602, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5603, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5604, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5605, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3520, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5606, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5607, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5608, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5609, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5610, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5611, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5612, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5613, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5614, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5615, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5616, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5617, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5618, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5619, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5620, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5621, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5622, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5623, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5624, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5625, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5626, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5627, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5628, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5629, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5630, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5631, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5632, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5633, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5634, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5635, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5636, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5637, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5638, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5639, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5640, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5641, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5642, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5643, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5645, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5647, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5649, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5650, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5651, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5652, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5654, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5656, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5658, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5659, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13852, 13852, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13854, 13854, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13856, 13856, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22050, 22050, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22053, 22053, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13864, 13866, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13866, 13866, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13868, 13868, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13870, 13870, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13872, 13872, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13874, 13874, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13876, 13876, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13878, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_MN, 26, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13880, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 5690, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 2839, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 2842, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 5691, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 5692, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 5693, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 5694, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 5695, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 5696, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_FONT, 2799, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13889, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13891, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13893, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13895, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13897, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13899, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13901, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13903, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13905, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13907, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13909, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13911, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13913, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13915, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13917, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13919, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13921, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13923, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13925, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13927, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13929, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13931, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13933, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13935, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13937, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13939, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13941, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13943, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13945, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13947, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13949, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13951, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_COMPAT, 13953, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5763, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5763, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5764, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5764, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5764, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5764, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5765, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5765, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5765, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5765, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5766, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5766, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5766, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5766, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5767, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5767, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5767, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5767, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5768, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5768, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5768, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5768, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5769, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5769, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5769, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5769, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5770, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5770, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5770, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5770, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5771, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5771, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5771, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5771, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5772, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5772, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5772, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5772, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5773, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5773, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5773, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5773, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5774, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5774, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5774, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5774, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5775, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5775, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5775, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5775, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5776, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5776, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5777, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5777, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5778, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5778, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5779, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5779, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5780, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5780, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5781, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5781, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5782, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5782, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5782, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5782, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5783, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5783, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5783, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5783, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5784, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5784, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5784, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5784, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5785, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5785, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5785, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5785, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5786, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5786, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5787, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5787, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5787, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5787, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5788, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5788, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5789, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5789, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5789, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5789, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5790, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5790, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5790, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5790, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5791, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5791, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5792, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5792, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5793, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5793, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5793, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5793, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5794, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5794, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5795, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5795, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5796, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5796, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5797, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5798, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5798, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5799, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5799, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5800, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5800, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5802, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5802, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 13995, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 13995, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 13997, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 13997, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 13999, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 13999, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14001, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14001, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14003, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14003, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14005, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14005, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14007, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14007, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14007, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14009, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14009, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14009, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5819, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5819, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5819, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5819, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14012, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14014, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14016, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14018, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14020, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14022, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14024, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14026, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14028, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14030, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14032, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14034, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14036, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14038, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14040, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14042, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14044, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14046, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14048, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14050, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14052, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14054, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14056, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14058, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14060, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14062, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14064, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14066, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14068, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14070, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14072, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14074, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14076, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14078, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14080, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14082, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14084, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14086, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14088, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14090, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14092, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14094, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14096, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14098, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14100, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14102, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14104, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14106, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14108, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14110, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14112, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14114, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14116, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14118, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14120, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14122, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14124, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14126, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14128, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14130, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14132, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14134, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14136, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14138, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14140, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14142, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14144, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14146, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14148, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14150, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14152, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14154, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14156, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14158, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14160, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14162, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14164, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14166, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14168, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14170, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14172, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14174, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14176, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14178, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14180, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14182, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14184, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14186, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14188, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14190, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14192, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14194, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14196, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 22390, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 22393, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 22396, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 22399, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 22402, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 22405, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14216, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14218, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14016, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14220, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14018, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14222, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14224, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14026, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14226, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14028, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14030, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14228, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14230, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14038, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14232, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14040, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14042, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14234, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14236, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14046, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14238, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14048, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14050, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14108, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14110, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14116, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14118, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14120, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14128, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14130, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14132, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14134, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14142, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14144, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14146, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14240, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14154, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14242, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14244, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14166, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14246, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14168, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14170, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14196, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14248, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14250, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14186, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14252, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14188, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14190, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14012, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14014, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14254, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14016, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14256, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14020, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14022, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14024, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14026, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14258, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14032, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14034, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14036, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14038, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14260, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14046, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14052, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14054, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14056, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14058, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14060, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14064, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14066, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14068, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14070, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14072, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14074, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14262, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14076, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14078, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14080, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14082, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14084, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14086, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14090, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14092, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14094, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14096, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14098, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14100, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14102, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14104, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14106, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14112, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14114, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14122, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14124, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14126, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14128, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14130, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14136, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14138, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14140, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14142, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14264, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14148, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14150, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14152, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14154, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14160, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14162, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14164, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14166, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14266, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14172, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14174, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14268, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14180, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14182, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14184, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14186, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14270, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14016, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14256, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14026, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14258, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14038, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14260, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14046, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14272, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14072, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14274, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14278, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14128, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14130, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14142, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14166, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14266, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14186, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14270, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 22472, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 22475, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 22478, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14289, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14291, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14293, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14295, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14297, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14299, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14301, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14303, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14305, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14307, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14309, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14311, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14313, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14315, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14317, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14319, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14321, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14323, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14325, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14327, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14329, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14331, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14333, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14335, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14337, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14339, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14341, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14289, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14291, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14293, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14295, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14297, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14299, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14301, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14303, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14305, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14307, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14309, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14311, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14313, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14315, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14317, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14319, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14321, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14323, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14325, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14327, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14329, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14331, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14333, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14335, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14337, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14339, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14341, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14329, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14331, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14333, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14274, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14278, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14088, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14066, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14068, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14070, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14329, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14331, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14333, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14088, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14090, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14343, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14343, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22537, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22540, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22540, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22543, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22546, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22549, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22552, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22555, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22558, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22558, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22561, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22564, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22567, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22570, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22573, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22576, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22576, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22579, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22582, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22582, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22585, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22585, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22588, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22591, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22591, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22594, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22597, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22597, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22603, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22606, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22606, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22609, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22609, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22612, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22615, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22618, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22621, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22621, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22624, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22627, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22630, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22633, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22636, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22636, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22639, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22642, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22645, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22648, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22651, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22654, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22654, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22657, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22657, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22660, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22660, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22663, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22666, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22669, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22672, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22675, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22678, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22681, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22684, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22687, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22690, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22693, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22696, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22699, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22699, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22702, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22705, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22708, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22711, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22711, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22714, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22717, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22720, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22723, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22726, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22729, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22732, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22735, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22738, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22741, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22744, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22747, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22750, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22753, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22756, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22759, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22762, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22765, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22768, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22771, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22774, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22777, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22639, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22645, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22780, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22783, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22786, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22789, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22792, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22795, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22792, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22786, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22798, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22804, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22807, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22810, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22795, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22618, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22588, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22813, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22816, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 22819, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 22822, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 31017, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 31021, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 31025, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 31029, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 31033, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 31037, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 31041, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 22853, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 63816, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 63835, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 31076, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6504, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6505, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6506, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6507, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 814, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6508, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6509, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6510, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6511, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6512, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6513, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6514, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6515, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PC, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6516, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 2802, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 2803, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6517, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6518, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6519, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6520, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6521, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6522, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6523, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6524, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 3063, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 3064, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6525, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6526, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6527, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6528, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6529, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6530, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 6531, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PC, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 6516, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_SMALL, 6504, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 6505, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_SMALL, 2762, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 814, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_SMALL, 6507, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 6509, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 6508, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 6514, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 2802, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 2803, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 6517, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 6518, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 6519, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 6520, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_SMALL, 6532, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 6533, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 6534, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_SMALL, 2799, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_SMALL, 6535, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 6536, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 6537, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 2801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 6538, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_SMALL, 6539, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_SMALL, 6540, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 6541, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14734, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14736, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14738, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14740, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14742, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14744, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14746, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14748, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14750, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14752, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14754, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14756, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14758, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14760, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6570, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6571, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6571, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6572, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6572, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6573, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6573, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6574, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6574, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6575, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6575, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6575, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6575, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6576, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6576, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6577, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6577, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6577, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6577, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6578, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6578, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6579, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6579, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6579, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6579, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6580, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6580, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6580, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6580, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6581, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6581, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6581, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6581, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6582, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6582, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6582, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6582, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6583, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6583, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6583, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6583, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6584, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6584, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6585, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6585, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6586, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6586, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6587, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6587, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6588, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6588, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6588, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6588, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6589, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6589, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6589, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6589, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6590, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6590, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6590, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6590, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6591, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6591, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6591, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6591, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6592, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6592, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6592, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6592, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6593, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6593, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6593, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6593, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6594, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6594, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6594, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6594, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6595, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6595, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6595, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6595, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6596, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6596, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6596, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6596, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6597, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6597, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6597, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6597, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6598, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6598, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6598, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6598, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6599, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6599, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6599, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6599, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6601, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6601, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6601, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6601, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6602, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6602, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6602, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6602, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6603, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6603, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5802, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5802, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6604, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6604, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6604, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6604, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14797, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14797, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14799, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14799, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14803, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14803, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6508, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6613, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_WIDE, 6532, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_WIDE, 6539, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_WIDE, 6540, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6533, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6614, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 2802, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 2803, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6534, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_WIDE, 2799, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_WIDE, 6504, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_WIDE, 6535, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_WIDE, 2762, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_WIDE, 6615, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 2792, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 38, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 31, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 32, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 2793, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 2794, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 2795, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 2796, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 2797, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 2798, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_WIDE, 6507, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 814, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6536, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 2801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6537, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6509, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6541, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1491, 6616, UINT16_MAX, 6616, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1493, 6617, UINT16_MAX, 6617, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 2812, 6618, UINT16_MAX, 6618, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1494, 6619, UINT16_MAX, 6619, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1495, 6620, UINT16_MAX, 6620, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 2837, 6621, UINT16_MAX, 6621, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1497, 6622, UINT16_MAX, 6622, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1498, 6623, UINT16_MAX, 6623, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1499, 6624, UINT16_MAX, 6624, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1500, 6625, UINT16_MAX, 6625, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1501, 6626, UINT16_MAX, 6626, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1502, 6627, UINT16_MAX, 6627, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1503, 6628, UINT16_MAX, 6628, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1504, 6629, UINT16_MAX, 6629, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1505, 6630, UINT16_MAX, 6630, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1507, 6631, UINT16_MAX, 6631, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 2826, 6632, UINT16_MAX, 6632, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1508, 6633, UINT16_MAX, 6633, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 3305, 6634, UINT16_MAX, 6634, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1509, 6635, UINT16_MAX, 6635, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1510, 6636, UINT16_MAX, 6636, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 2908, 6637, UINT16_MAX, 6637, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1511, 6638, UINT16_MAX, 6638, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 2925, 6639, UINT16_MAX, 6639, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 3312, 6640, UINT16_MAX, 6640, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 2834, 6641, UINT16_MAX, 6641, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6529, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6538, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6530, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6642, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PC, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6516, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 2722, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 0, UINT16_MAX, 9167, UINT16_MAX, 9167, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1, UINT16_MAX, 9168, UINT16_MAX, 9168, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 2, UINT16_MAX, 9169, UINT16_MAX, 9169, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 3, UINT16_MAX, 9170, UINT16_MAX, 9170, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 4, UINT16_MAX, 9171, UINT16_MAX, 9171, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 5, UINT16_MAX, 9172, UINT16_MAX, 9172, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 6, UINT16_MAX, 9173, UINT16_MAX, 9173, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 7, UINT16_MAX, 9174, UINT16_MAX, 9174, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 8, UINT16_MAX, 9175, UINT16_MAX, 9175, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 9, UINT16_MAX, 9176, UINT16_MAX, 9176, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 10, UINT16_MAX, 9177, UINT16_MAX, 9177, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 11, UINT16_MAX, 9178, UINT16_MAX, 9178, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 12, UINT16_MAX, 9179, UINT16_MAX, 9179, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 13, UINT16_MAX, 9180, UINT16_MAX, 9180, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 14, UINT16_MAX, 9181, UINT16_MAX, 9181, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 15, UINT16_MAX, 9182, UINT16_MAX, 9182, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 16, UINT16_MAX, 9183, UINT16_MAX, 9183, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 17, UINT16_MAX, 9184, UINT16_MAX, 9184, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 18, UINT16_MAX, 9185, UINT16_MAX, 9185, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 19, UINT16_MAX, 9186, UINT16_MAX, 9186, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 20, UINT16_MAX, 9187, UINT16_MAX, 9187, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 21, UINT16_MAX, 9188, UINT16_MAX, 9188, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 22, UINT16_MAX, 9189, UINT16_MAX, 9189, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 23, UINT16_MAX, 9190, UINT16_MAX, 9190, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 24, UINT16_MAX, 9191, UINT16_MAX, 9191, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 25, UINT16_MAX, 9192, UINT16_MAX, 9192, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6517, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6643, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6518, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6644, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6645, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6646, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 6506, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 6525, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 6526, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 6505, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 6647, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4331, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6648, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6649, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6650, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6651, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6652, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6653, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6654, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6655, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6656, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6657, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4285, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4286, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4287, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4288, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4289, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4290, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4291, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4292, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4293, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4294, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4295, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4296, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4297, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4298, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4299, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4300, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4301, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4302, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4303, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4304, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4305, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4306, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4307, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4308, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4309, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4310, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4311, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4312, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4313, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4314, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4315, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4316, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4317, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4318, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4319, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4320, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4321, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4322, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4323, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4324, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4325, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4326, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4327, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4328, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6658, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6659, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6660, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6661, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6662, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6663, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6664, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6665, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6666, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6667, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6668, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6669, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6670, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6671, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6672, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6673, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6674, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6675, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6676, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6677, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6678, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6679, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6680, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6681, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6682, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6683, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6684, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6685, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6686, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6687, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6688, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6689, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6690, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6691, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6692, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6693, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6694, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6695, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6696, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6697, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6698, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6699, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6700, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6701, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6702, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6703, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6704, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6705, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6706, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6707, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6708, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6709, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6710, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6711, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6712, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_WIDE, 6713, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_WIDE, 6714, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6715, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6716, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6717, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_WIDE, 6718, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_WIDE, 6719, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 6720, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 6721, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 6722, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 6723, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 6724, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 6725, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 6726, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL}, - {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6727, UINT16_MAX, 6727, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6729, UINT16_MAX, 6729, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6731, UINT16_MAX, 6731, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6733, UINT16_MAX, 6733, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6735, UINT16_MAX, 6735, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6737, UINT16_MAX, 6737, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6739, UINT16_MAX, 6739, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6741, UINT16_MAX, 6741, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6743, UINT16_MAX, 6743, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6745, UINT16_MAX, 6745, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6747, UINT16_MAX, 6747, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6749, UINT16_MAX, 6749, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6751, UINT16_MAX, 6751, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6753, UINT16_MAX, 6753, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6755, UINT16_MAX, 6755, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6757, UINT16_MAX, 6757, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6759, UINT16_MAX, 6759, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6761, UINT16_MAX, 6761, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6763, UINT16_MAX, 6763, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6765, UINT16_MAX, 6765, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6767, UINT16_MAX, 6767, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6769, UINT16_MAX, 6769, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6771, UINT16_MAX, 6771, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6773, UINT16_MAX, 6773, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6775, UINT16_MAX, 6775, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6777, UINT16_MAX, 6777, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6779, UINT16_MAX, 6779, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6781, UINT16_MAX, 6781, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6783, UINT16_MAX, 6783, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6785, UINT16_MAX, 6785, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6787, UINT16_MAX, 6787, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6789, UINT16_MAX, 6789, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6791, UINT16_MAX, 6791, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6793, UINT16_MAX, 6793, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6795, UINT16_MAX, 6795, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6797, UINT16_MAX, 6797, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6799, UINT16_MAX, 6799, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6801, UINT16_MAX, 6801, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6803, UINT16_MAX, 6803, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6805, UINT16_MAX, 6805, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9193, UINT16_MAX, 9193, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9195, UINT16_MAX, 9195, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9197, UINT16_MAX, 9197, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9199, UINT16_MAX, 9199, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9201, UINT16_MAX, 9201, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9203, UINT16_MAX, 9203, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9205, UINT16_MAX, 9205, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9207, UINT16_MAX, 9207, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9209, UINT16_MAX, 9209, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9211, UINT16_MAX, 9211, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9213, UINT16_MAX, 9213, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9215, UINT16_MAX, 9215, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9217, UINT16_MAX, 9217, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9219, UINT16_MAX, 9219, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9221, UINT16_MAX, 9221, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9223, UINT16_MAX, 9223, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9225, UINT16_MAX, 9225, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9227, UINT16_MAX, 9227, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9229, UINT16_MAX, 9229, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9231, UINT16_MAX, 9231, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9233, UINT16_MAX, 9233, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9235, UINT16_MAX, 9235, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9237, UINT16_MAX, 9237, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9239, UINT16_MAX, 9239, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9241, UINT16_MAX, 9241, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9243, UINT16_MAX, 9243, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9245, UINT16_MAX, 9245, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9247, UINT16_MAX, 9247, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9249, UINT16_MAX, 9249, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9251, UINT16_MAX, 9251, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9253, UINT16_MAX, 9253, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9255, UINT16_MAX, 9255, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9257, UINT16_MAX, 9257, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9259, UINT16_MAX, 9259, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9261, UINT16_MAX, 9261, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9263, UINT16_MAX, 9263, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9265, UINT16_MAX, 9265, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9267, UINT16_MAX, 9267, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9269, UINT16_MAX, 9269, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9271, UINT16_MAX, 9271, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6807, UINT16_MAX, 6807, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6809, UINT16_MAX, 6809, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6811, UINT16_MAX, 6811, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6813, UINT16_MAX, 6813, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6815, UINT16_MAX, 6815, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6817, UINT16_MAX, 6817, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6819, UINT16_MAX, 6819, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6821, UINT16_MAX, 6821, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6823, UINT16_MAX, 6823, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6825, UINT16_MAX, 6825, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6827, UINT16_MAX, 6827, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6829, UINT16_MAX, 6829, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6831, UINT16_MAX, 6831, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6833, UINT16_MAX, 6833, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6835, UINT16_MAX, 6835, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6837, UINT16_MAX, 6837, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6839, UINT16_MAX, 6839, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6841, UINT16_MAX, 6841, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6843, UINT16_MAX, 6843, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6845, UINT16_MAX, 6845, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6847, UINT16_MAX, 6847, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6849, UINT16_MAX, 6849, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6851, UINT16_MAX, 6851, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6853, UINT16_MAX, 6853, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6855, UINT16_MAX, 6855, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6857, UINT16_MAX, 6857, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6859, UINT16_MAX, 6859, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6861, UINT16_MAX, 6861, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6863, UINT16_MAX, 6863, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6865, UINT16_MAX, 6865, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6867, UINT16_MAX, 6867, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6869, UINT16_MAX, 6869, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6871, UINT16_MAX, 6871, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6873, UINT16_MAX, 6873, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6875, UINT16_MAX, 6875, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6877, UINT16_MAX, 6877, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9273, UINT16_MAX, 9273, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9275, UINT16_MAX, 9275, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9277, UINT16_MAX, 9277, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9279, UINT16_MAX, 9279, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9281, UINT16_MAX, 9281, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9283, UINT16_MAX, 9283, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9285, UINT16_MAX, 9285, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9287, UINT16_MAX, 9287, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9289, UINT16_MAX, 9289, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9291, UINT16_MAX, 9291, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9293, UINT16_MAX, 9293, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9295, UINT16_MAX, 9295, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9297, UINT16_MAX, 9297, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9299, UINT16_MAX, 9299, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9301, UINT16_MAX, 9301, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9303, UINT16_MAX, 9303, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9305, UINT16_MAX, 9305, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9307, UINT16_MAX, 9307, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9309, UINT16_MAX, 9309, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9311, UINT16_MAX, 9311, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9313, UINT16_MAX, 9313, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9315, UINT16_MAX, 9315, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9317, UINT16_MAX, 9317, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9319, UINT16_MAX, 9319, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9321, UINT16_MAX, 9321, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9323, UINT16_MAX, 9323, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9325, UINT16_MAX, 9325, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9327, UINT16_MAX, 9327, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9329, UINT16_MAX, 9329, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9331, UINT16_MAX, 9331, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9333, UINT16_MAX, 9333, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9335, UINT16_MAX, 9335, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9337, UINT16_MAX, 9337, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9339, UINT16_MAX, 9339, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9341, UINT16_MAX, 9341, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9343, UINT16_MAX, 9343, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6879, UINT16_MAX, 6879, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6881, UINT16_MAX, 6881, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6883, UINT16_MAX, 6883, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6885, UINT16_MAX, 6885, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6887, UINT16_MAX, 6887, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6889, UINT16_MAX, 6889, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6891, UINT16_MAX, 6891, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6893, UINT16_MAX, 6893, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6895, UINT16_MAX, 6895, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6897, UINT16_MAX, 6897, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6899, UINT16_MAX, 6899, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6901, UINT16_MAX, 6901, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6903, UINT16_MAX, 6903, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6905, UINT16_MAX, 6905, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6907, UINT16_MAX, 6907, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6909, UINT16_MAX, 6909, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6911, UINT16_MAX, 6911, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6913, UINT16_MAX, 6913, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6915, UINT16_MAX, 6915, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6917, UINT16_MAX, 6917, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6919, UINT16_MAX, 6919, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6921, UINT16_MAX, 6921, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6923, UINT16_MAX, 6923, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6925, UINT16_MAX, 6925, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6927, UINT16_MAX, 6927, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6929, UINT16_MAX, 6929, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6931, UINT16_MAX, 6931, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6933, UINT16_MAX, 6933, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6935, UINT16_MAX, 6935, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6937, UINT16_MAX, 6937, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6939, UINT16_MAX, 6939, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6941, UINT16_MAX, 6941, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6943, UINT16_MAX, 6943, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6945, UINT16_MAX, 6945, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6947, UINT16_MAX, 6947, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6949, UINT16_MAX, 6949, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6951, UINT16_MAX, 6951, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6953, UINT16_MAX, 6953, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6955, UINT16_MAX, 6955, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6957, UINT16_MAX, 6957, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6959, UINT16_MAX, 6959, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6961, UINT16_MAX, 6961, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6963, UINT16_MAX, 6963, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6965, UINT16_MAX, 6965, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6967, UINT16_MAX, 6967, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6969, UINT16_MAX, 6969, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6971, UINT16_MAX, 6971, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6973, UINT16_MAX, 6973, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6975, UINT16_MAX, 6975, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6977, UINT16_MAX, 6977, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6979, UINT16_MAX, 6979, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9345, UINT16_MAX, 9345, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9347, UINT16_MAX, 9347, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9349, UINT16_MAX, 9349, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9351, UINT16_MAX, 9351, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9353, UINT16_MAX, 9353, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9355, UINT16_MAX, 9355, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9357, UINT16_MAX, 9357, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9359, UINT16_MAX, 9359, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9361, UINT16_MAX, 9361, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9363, UINT16_MAX, 9363, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9365, UINT16_MAX, 9365, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9367, UINT16_MAX, 9367, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9369, UINT16_MAX, 9369, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9371, UINT16_MAX, 9371, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9373, UINT16_MAX, 9373, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9375, UINT16_MAX, 9375, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9377, UINT16_MAX, 9377, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9379, UINT16_MAX, 9379, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9381, UINT16_MAX, 9381, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9383, UINT16_MAX, 9383, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9385, UINT16_MAX, 9385, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9387, UINT16_MAX, 9387, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9389, UINT16_MAX, 9389, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9391, UINT16_MAX, 9391, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9393, UINT16_MAX, 9393, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9395, UINT16_MAX, 9395, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9397, UINT16_MAX, 9397, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9399, UINT16_MAX, 9399, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9401, UINT16_MAX, 9401, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9403, UINT16_MAX, 9403, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9405, UINT16_MAX, 9405, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9407, UINT16_MAX, 9407, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9409, UINT16_MAX, 9409, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9411, UINT16_MAX, 9411, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9413, UINT16_MAX, 9413, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9415, UINT16_MAX, 9415, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9417, UINT16_MAX, 9417, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9419, UINT16_MAX, 9419, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9421, UINT16_MAX, 9421, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9423, UINT16_MAX, 9423, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9425, UINT16_MAX, 9425, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9427, UINT16_MAX, 9427, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9429, UINT16_MAX, 9429, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9431, UINT16_MAX, 9431, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9433, UINT16_MAX, 9433, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9435, UINT16_MAX, 9435, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9437, UINT16_MAX, 9437, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9439, UINT16_MAX, 9439, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9441, UINT16_MAX, 9441, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9443, UINT16_MAX, 9443, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9445, UINT16_MAX, 9445, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_AN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5328, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15173, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5332, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15177, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5336, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15181, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_MN, 7, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49206, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_PREPEND}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49208, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 15185, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 15189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5340, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5344, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49210, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5348, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 15193, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 15197, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49212, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49216, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5354, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49214, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 15201, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 15205, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49218, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 15209, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49220, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5362, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5366, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 15213, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 15217, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7029, UINT16_MAX, 7029, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7031, UINT16_MAX, 7031, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7033, UINT16_MAX, 7033, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7035, UINT16_MAX, 7035, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7037, UINT16_MAX, 7037, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7039, UINT16_MAX, 7039, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7041, UINT16_MAX, 7041, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7043, UINT16_MAX, 7043, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7045, UINT16_MAX, 7045, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7047, UINT16_MAX, 7047, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7049, UINT16_MAX, 7049, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7051, UINT16_MAX, 7051, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7053, UINT16_MAX, 7053, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7055, UINT16_MAX, 7055, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7057, UINT16_MAX, 7057, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7059, UINT16_MAX, 7059, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7061, UINT16_MAX, 7061, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7063, UINT16_MAX, 7063, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7065, UINT16_MAX, 7065, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7067, UINT16_MAX, 7067, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7069, UINT16_MAX, 7069, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7071, UINT16_MAX, 7071, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7073, UINT16_MAX, 7073, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7075, UINT16_MAX, 7075, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7077, UINT16_MAX, 7077, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7079, UINT16_MAX, 7079, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7081, UINT16_MAX, 7081, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7083, UINT16_MAX, 7083, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7085, UINT16_MAX, 7085, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7087, UINT16_MAX, 7087, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7089, UINT16_MAX, 7089, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7091, UINT16_MAX, 7091, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9447, UINT16_MAX, 9447, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9449, UINT16_MAX, 9449, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9451, UINT16_MAX, 9451, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9453, UINT16_MAX, 9453, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9455, UINT16_MAX, 9455, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9457, UINT16_MAX, 9457, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9459, UINT16_MAX, 9459, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9461, UINT16_MAX, 9461, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9463, UINT16_MAX, 9463, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9465, UINT16_MAX, 9465, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9467, UINT16_MAX, 9467, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9469, UINT16_MAX, 9469, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9471, UINT16_MAX, 9471, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9473, UINT16_MAX, 9473, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9475, UINT16_MAX, 9475, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9477, UINT16_MAX, 9477, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9479, UINT16_MAX, 9479, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9481, UINT16_MAX, 9481, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9483, UINT16_MAX, 9483, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9485, UINT16_MAX, 9485, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9487, UINT16_MAX, 9487, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9489, UINT16_MAX, 9489, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9491, UINT16_MAX, 9491, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9493, UINT16_MAX, 9493, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9495, UINT16_MAX, 9495, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9497, UINT16_MAX, 9497, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9499, UINT16_MAX, 9499, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9501, UINT16_MAX, 9501, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9503, UINT16_MAX, 9503, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9505, UINT16_MAX, 9505, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9507, UINT16_MAX, 9507, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9509, UINT16_MAX, 9509, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MN, 9, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7093, UINT16_MAX, 7093, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7095, UINT16_MAX, 7095, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7097, UINT16_MAX, 7097, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7099, UINT16_MAX, 7099, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7101, UINT16_MAX, 7101, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7103, UINT16_MAX, 7103, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7105, UINT16_MAX, 7105, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7107, UINT16_MAX, 7107, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7109, UINT16_MAX, 7109, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7111, UINT16_MAX, 7111, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7113, UINT16_MAX, 7113, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7115, UINT16_MAX, 7115, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7117, UINT16_MAX, 7117, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7119, UINT16_MAX, 7119, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7121, UINT16_MAX, 7121, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7123, UINT16_MAX, 7123, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7125, UINT16_MAX, 7125, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7127, UINT16_MAX, 7127, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7129, UINT16_MAX, 7129, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7131, UINT16_MAX, 7131, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7133, UINT16_MAX, 7133, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7135, UINT16_MAX, 7135, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7137, UINT16_MAX, 7137, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7139, UINT16_MAX, 7139, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7141, UINT16_MAX, 7141, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7143, UINT16_MAX, 7143, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7145, UINT16_MAX, 7145, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7147, UINT16_MAX, 7147, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7149, UINT16_MAX, 7149, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7151, UINT16_MAX, 7151, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7153, UINT16_MAX, 7153, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7155, UINT16_MAX, 7155, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9511, UINT16_MAX, 9511, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9513, UINT16_MAX, 9513, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9515, UINT16_MAX, 9515, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9517, UINT16_MAX, 9517, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9519, UINT16_MAX, 9519, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9521, UINT16_MAX, 9521, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9523, UINT16_MAX, 9523, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9525, UINT16_MAX, 9525, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9527, UINT16_MAX, 9527, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9529, UINT16_MAX, 9529, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9531, UINT16_MAX, 9531, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9533, UINT16_MAX, 9533, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9535, UINT16_MAX, 9535, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9537, UINT16_MAX, 9537, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9539, UINT16_MAX, 9539, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9541, UINT16_MAX, 9541, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9543, UINT16_MAX, 9543, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9545, UINT16_MAX, 9545, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9547, UINT16_MAX, 9547, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9549, UINT16_MAX, 9549, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9551, UINT16_MAX, 9551, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9553, UINT16_MAX, 9553, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9555, UINT16_MAX, 9555, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9557, UINT16_MAX, 9557, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9559, UINT16_MAX, 9559, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9561, UINT16_MAX, 9561, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9563, UINT16_MAX, 9563, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9565, UINT16_MAX, 9565, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9567, UINT16_MAX, 9567, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9569, UINT16_MAX, 9569, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9571, UINT16_MAX, 9571, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9573, UINT16_MAX, 9573, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5370, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5374, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15349, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15353, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5378, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15357, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15361, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15365, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15369, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15373, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_MC, 216, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49222, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MC, 216, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 226, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK}, - {UTF8PROC_CATEGORY_MC, 216, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49224, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MC, 216, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49226, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MC, 216, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49228, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MC, 216, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49230, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_MC, 216, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49232, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5390, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5394, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15377, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5398, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15381, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5404, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15385, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15389, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15393, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15397, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1491, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1497, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1500, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1501, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1505, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3305, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1509, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1510, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2908, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1511, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2925, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3312, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 5, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 12, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 13, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 15, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 16, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 17, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 18, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 19, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 20, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 21, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 22, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 23, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 24, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 25, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7209, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7210, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7211, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7212, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7213, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7214, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7215, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7216, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 915, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7217, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7218, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7219, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7220, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7221, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7222, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7223, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7224, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7225, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 917, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7226, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 897, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7227, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7228, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7229, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2835, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7230, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 845, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 846, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 848, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 849, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 850, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 851, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 852, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 807, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 853, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 854, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 35, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 855, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 856, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 857, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 859, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 914, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 860, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 861, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 862, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 863, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 864, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 865, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 866, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FONT, 7231, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7232, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7233, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7234, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7235, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7236, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7237, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7238, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 904, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 2792, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 38, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 31, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 32, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 2793, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 2794, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 2795, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 2796, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 2797, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 2798, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7239, UINT16_MAX, 7239, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7241, UINT16_MAX, 7241, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7243, UINT16_MAX, 7243, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7245, UINT16_MAX, 7245, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7247, UINT16_MAX, 7247, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7249, UINT16_MAX, 7249, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7251, UINT16_MAX, 7251, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7253, UINT16_MAX, 7253, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7255, UINT16_MAX, 7255, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7257, UINT16_MAX, 7257, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7259, UINT16_MAX, 7259, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7261, UINT16_MAX, 7261, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7263, UINT16_MAX, 7263, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7265, UINT16_MAX, 7265, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7267, UINT16_MAX, 7267, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7269, UINT16_MAX, 7269, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7271, UINT16_MAX, 7271, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7273, UINT16_MAX, 7273, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7275, UINT16_MAX, 7275, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7277, UINT16_MAX, 7277, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7279, UINT16_MAX, 7279, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7281, UINT16_MAX, 7281, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7283, UINT16_MAX, 7283, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7285, UINT16_MAX, 7285, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7287, UINT16_MAX, 7287, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7289, UINT16_MAX, 7289, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7291, UINT16_MAX, 7291, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7293, UINT16_MAX, 7293, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7295, UINT16_MAX, 7295, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7297, UINT16_MAX, 7297, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7299, UINT16_MAX, 7299, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7301, UINT16_MAX, 7301, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7303, UINT16_MAX, 7303, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7305, UINT16_MAX, 7305, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9575, UINT16_MAX, 9575, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9577, UINT16_MAX, 9577, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9579, UINT16_MAX, 9579, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9581, UINT16_MAX, 9581, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9583, UINT16_MAX, 9583, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9585, UINT16_MAX, 9585, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9587, UINT16_MAX, 9587, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9589, UINT16_MAX, 9589, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9591, UINT16_MAX, 9591, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9593, UINT16_MAX, 9593, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9595, UINT16_MAX, 9595, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9597, UINT16_MAX, 9597, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9599, UINT16_MAX, 9599, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9601, UINT16_MAX, 9601, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9603, UINT16_MAX, 9603, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9605, UINT16_MAX, 9605, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9607, UINT16_MAX, 9607, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9609, UINT16_MAX, 9609, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9611, UINT16_MAX, 9611, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9613, UINT16_MAX, 9613, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9615, UINT16_MAX, 9615, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9617, UINT16_MAX, 9617, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9619, UINT16_MAX, 9619, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9621, UINT16_MAX, 9621, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9623, UINT16_MAX, 9623, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9625, UINT16_MAX, 9625, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9627, UINT16_MAX, 9627, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9629, UINT16_MAX, 9629, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9631, UINT16_MAX, 9631, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9633, UINT16_MAX, 9633, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9635, UINT16_MAX, 9635, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9637, UINT16_MAX, 9637, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9639, UINT16_MAX, 9639, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9641, UINT16_MAX, 9641, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6576, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6577, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6581, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6584, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6603, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6587, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6582, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6592, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6604, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6598, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6599, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6601, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6588, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6594, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6596, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6590, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6597, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6586, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6589, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6579, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6580, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6583, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6585, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6591, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6593, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6595, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 7307, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 5786, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 7308, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 7309, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6602, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 15502, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 15504, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 15506, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 15508, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 15510, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 15512, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 15514, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 15516, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 15518, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 15520, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 15522, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23716, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23719, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23722, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23725, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23728, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23731, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23734, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23737, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23740, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23743, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23746, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23749, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23752, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23755, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23758, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23761, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23764, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23767, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23770, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23773, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23776, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23779, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23782, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23785, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23788, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23791, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23794, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 2812, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1508, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 15605, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 15607, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1491, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1493, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 2812, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1494, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1495, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 2837, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1497, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1498, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1499, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1500, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1501, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1502, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1503, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1504, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1505, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1507, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 2826, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1508, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 3305, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1509, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1510, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 2908, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1511, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 2925, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 3312, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 2834, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 15609, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13070, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 15611, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 15613, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 23807, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 15618, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 15620, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 15622, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 15624, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 15626, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_REGIONAL_INDICATOR}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 15628, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 15630, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 4295, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 3506, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7440, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7441, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7442, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 3449, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7443, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7444, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 3886, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7445, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7446, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7447, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 5425, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7448, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7449, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7450, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7451, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7452, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7453, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 3542, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7454, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7455, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7456, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7457, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7458, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7459, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 3443, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 3878, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7460, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 4208, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 3881, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 4209, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7461, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 3598, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7462, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7463, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7464, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7465, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7466, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 4191, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 3516, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7467, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7468, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7469, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7470, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23855, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23858, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23861, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23864, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23867, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23870, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23873, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23876, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23879, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 7498, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 7499, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC}, - {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTEND}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7500, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7501, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7502, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7503, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7505, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7506, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7507, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7508, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7509, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7510, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7511, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7512, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7514, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7515, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7516, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7517, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7519, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7520, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7450, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7521, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7523, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7524, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7525, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7526, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7527, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3459, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7529, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7530, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7531, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7532, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7468, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7533, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7534, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7535, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7536, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7537, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7538, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7539, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7540, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7541, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7542, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7544, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7545, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7546, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7547, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7549, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7550, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7551, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7552, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7553, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7554, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7555, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7556, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7557, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7558, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7559, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7560, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7561, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7562, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7563, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7564, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7565, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7566, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7567, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7568, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7569, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7570, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7571, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7572, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7573, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7574, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7575, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7576, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7577, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7579, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7580, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7581, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7443, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7582, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7583, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7584, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7586, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7588, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7589, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7590, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7591, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7592, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7593, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7594, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7595, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7596, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7597, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7599, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7601, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7602, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7604, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7605, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7606, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3485, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7607, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7608, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7609, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7610, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7611, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7613, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7614, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7616, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7617, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7618, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7619, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7620, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7621, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7622, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7623, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7624, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7625, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7626, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7627, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7629, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7630, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7631, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7632, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7633, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3497, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7635, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7637, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7638, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7639, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7640, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7642, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7644, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7645, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7646, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7647, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7648, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7649, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7650, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7651, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7652, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7653, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7654, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7656, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7657, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7658, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7659, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7660, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7661, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7662, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7663, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7664, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7665, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7666, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7667, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7668, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7669, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7670, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7672, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7673, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7674, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7675, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7676, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7677, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7679, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7680, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7681, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7682, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7683, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7684, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7685, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7686, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7687, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7688, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7689, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7691, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7692, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7693, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7694, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7695, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7696, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7697, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7698, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7699, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7700, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7701, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7702, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7703, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7704, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7705, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7706, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7708, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7709, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7710, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7711, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7712, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7714, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7715, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7716, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7717, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7718, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7719, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7720, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7721, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7723, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7724, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7725, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7726, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7728, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7729, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7730, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7731, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7732, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7733, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7735, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7737, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7739, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7740, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7742, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7743, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7744, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7745, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7746, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7747, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7748, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7749, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7750, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7752, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7753, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7754, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7755, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7756, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7757, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7759, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7760, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7761, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7763, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7765, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7766, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7767, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7768, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7769, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7770, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7771, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7772, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7773, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7775, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7776, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7778, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7779, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7781, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7782, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7783, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7785, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7786, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7787, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7789, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7791, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7792, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7793, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7794, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7795, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7796, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7797, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7798, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7799, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7800, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7802, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7804, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7805, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7807, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7809, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7810, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7812, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7814, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7816, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7817, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7818, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7820, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7822, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7824, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7826, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7827, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7828, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7829, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7830, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7831, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7833, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7834, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7835, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7837, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7839, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7841, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7842, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7843, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7844, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7845, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7847, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7849, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7850, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7851, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7853, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7854, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7855, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7856, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7858, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7859, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7860, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7861, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7862, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7863, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7865, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7866, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7867, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7868, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7869, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7870, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7871, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7873, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7875, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7876, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7878, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7879, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7881, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7882, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7883, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7885, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7887, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7888, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7890, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7891, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7893, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7894, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7895, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7896, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7897, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7898, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7899, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7901, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7903, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7905, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7907, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7908, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7909, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7910, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7911, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7912, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7913, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7914, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7915, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7916, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7917, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7918, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7920, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7921, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7922, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7923, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7924, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7925, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7926, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7927, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7928, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7929, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7930, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7932, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7934, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7936, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7937, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7938, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7939, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7940, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7942, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7943, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7945, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7946, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7947, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7949, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7951, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7952, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7953, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7954, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7955, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7956, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7957, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7958, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7959, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7960, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7961, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7962, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7963, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7964, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7965, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7966, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3587, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7967, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7969, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7970, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7971, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7972, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7973, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7974, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7976, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7978, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7979, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7980, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3594, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7981, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7983, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7984, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7985, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7986, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7987, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7989, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7991, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7992, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7993, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7994, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7996, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7997, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7999, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8001, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8002, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8003, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8004, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8006, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8007, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8008, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8009, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8010, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8011, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8012, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8013, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8015, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8016, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8017, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8018, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8020, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8021, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8022, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8023, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8024, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8026, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8028, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8029, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8030, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8031, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8033, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8034, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8036, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8037, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8039, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8040, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8041, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8042, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8043, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8044, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8045, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8046, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8048, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8049, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8050, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8051, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8052, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8053, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8055, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8056, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8058, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8060, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3642, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8062, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3646, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8063, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8064, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8065, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8066, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3651, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, - {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8067, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER}, + {0, 0, 0, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false,false,false,false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_CC, 0, UTF8PROC_BIDI_CLASS_BN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_CC, 0, UTF8PROC_BIDI_CLASS_S, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_CC, 0, UTF8PROC_BIDI_CLASS_B, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_LF, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_CC, 0, UTF8PROC_BIDI_CLASS_WS, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_CC, 0, UTF8PROC_BIDI_CLASS_B, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CR, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_CC, 0, UTF8PROC_BIDI_CLASS_B, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ZS, 0, UTF8PROC_BIDI_CLASS_WS, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ET, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ES, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5093, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5084, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5096, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 0, UINT16_MAX, 0, UINT16_MAX, 0, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1, UINT16_MAX, 1, UINT16_MAX, 2784, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2, UINT16_MAX, 2, UINT16_MAX, 49, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3, UINT16_MAX, 3, UINT16_MAX, 704, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4, UINT16_MAX, 4, UINT16_MAX, 62, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5, UINT16_MAX, 5, UINT16_MAX, 2872, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6, UINT16_MAX, 6, UINT16_MAX, 782, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7, UINT16_MAX, 7, UINT16_MAX, 808, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8, UINT16_MAX, 8, UINT16_MAX, 111, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9, UINT16_MAX, 9, UINT16_MAX, 898, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 10, UINT16_MAX, 10, UINT16_MAX, 913, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 11, UINT16_MAX, 11, UINT16_MAX, 999, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 12, UINT16_MAX, 12, UINT16_MAX, 2890, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 13, UINT16_MAX, 13, UINT16_MAX, 160, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 14, UINT16_MAX, 14, UINT16_MAX, 205, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 15, UINT16_MAX, 15, UINT16_MAX, 2982, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 16, UINT16_MAX, 16, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 17, UINT16_MAX, 17, UINT16_MAX, 1087, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 18, UINT16_MAX, 18, UINT16_MAX, 1173, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 19, UINT16_MAX, 19, UINT16_MAX, 1257, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 20, UINT16_MAX, 20, UINT16_MAX, 254, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 21, UINT16_MAX, 21, UINT16_MAX, 3042, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 22, UINT16_MAX, 22, UINT16_MAX, 1337, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 23, UINT16_MAX, 23, UINT16_MAX, 3122, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 24, UINT16_MAX, 24, UINT16_MAX, 303, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 25, UINT16_MAX, 25, UINT16_MAX, 1423, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PC, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 26, UINT16_MAX, 26, 352, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 27, UINT16_MAX, 27, 2818, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 28, UINT16_MAX, 28, 401, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 29, UINT16_MAX, 29, 743, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 30, UINT16_MAX, 30, 414, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 31, UINT16_MAX, 31, 2875, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 32, UINT16_MAX, 32, 795, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 33, UINT16_MAX, 33, 853, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 34, UINT16_MAX, 34, 463, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 35, UINT16_MAX, 35, 901, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 36, UINT16_MAX, 36, 956, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 37, UINT16_MAX, 37, 1043, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 38, UINT16_MAX, 38, 2932, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 39, UINT16_MAX, 39, 512, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 40, UINT16_MAX, 40, 557, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 41, UINT16_MAX, 41, 2994, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 42, UINT16_MAX, 42, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 43, UINT16_MAX, 43, 1130, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 44, UINT16_MAX, 44, 1215, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 45, UINT16_MAX, 45, 1296, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 46, UINT16_MAX, 46, 606, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 47, UINT16_MAX, 47, 3082, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 48, UINT16_MAX, 48, 1380, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 49, UINT16_MAX, 49, 3131, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 50, UINT16_MAX, 50, 655, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 51, UINT16_MAX, 51, 1466, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ZS, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_NOBREAK, 52, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 16437, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 1621, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 0, UINT16_MAX, 55, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PI, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_BN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 1, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 16440, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ET, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ET, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 58, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 59, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 16444, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 62, 62, 63, UINT16_MAX, 63, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 16448, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 66, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 14, UINT16_MAX, 67, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PF, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 32836, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 32839, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 32842, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16461, 79, UINT16_MAX, 79, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16464, 82, UINT16_MAX, 82, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16467, 85, UINT16_MAX, 85, UINT16_MAX, 3143, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16470, 88, UINT16_MAX, 88, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16473, 91, UINT16_MAX, 91, UINT16_MAX, 1537, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16476, 94, UINT16_MAX, 94, UINT16_MAX, 1579, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 95, UINT16_MAX, 95, UINT16_MAX, 1549, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16480, 98, UINT16_MAX, 98, UINT16_MAX, 2852, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16483, 101, UINT16_MAX, 101, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16486, 104, UINT16_MAX, 104, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16489, 107, UINT16_MAX, 107, UINT16_MAX, 3357, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16492, 110, UINT16_MAX, 110, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16495, 113, UINT16_MAX, 113, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16498, 116, UINT16_MAX, 116, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16501, 119, UINT16_MAX, 119, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16504, 122, UINT16_MAX, 122, UINT16_MAX, 2878, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 123, UINT16_MAX, 123, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16508, 126, UINT16_MAX, 126, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16511, 129, UINT16_MAX, 129, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16514, 132, UINT16_MAX, 132, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16517, 135, UINT16_MAX, 135, UINT16_MAX, 3461, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16520, 138, UINT16_MAX, 138, UINT16_MAX, 1597, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16523, 141, UINT16_MAX, 141, UINT16_MAX, 1591, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 142, UINT16_MAX, 142, UINT16_MAX, 1585, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16527, 145, UINT16_MAX, 145, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16530, 148, UINT16_MAX, 148, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16533, 151, UINT16_MAX, 151, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16536, 154, UINT16_MAX, 154, UINT16_MAX, 1509, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16539, 157, UINT16_MAX, 157, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 158, UINT16_MAX, 158, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 16543, 161, UINT16_MAX, 161, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16546, UINT16_MAX, 164, UINT16_MAX, 164, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16549, UINT16_MAX, 167, UINT16_MAX, 167, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16552, UINT16_MAX, 170, UINT16_MAX, 170, 3192, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16555, UINT16_MAX, 173, UINT16_MAX, 173, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16558, UINT16_MAX, 176, UINT16_MAX, 176, 1540, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16561, UINT16_MAX, 179, UINT16_MAX, 179, 1582, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 180, UINT16_MAX, 180, 1558, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16565, UINT16_MAX, 183, UINT16_MAX, 183, 2855, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16568, UINT16_MAX, 186, UINT16_MAX, 186, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16571, UINT16_MAX, 189, UINT16_MAX, 189, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16574, UINT16_MAX, 192, UINT16_MAX, 192, 3406, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16577, UINT16_MAX, 195, UINT16_MAX, 195, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16580, UINT16_MAX, 198, UINT16_MAX, 198, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16583, UINT16_MAX, 201, UINT16_MAX, 201, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16586, UINT16_MAX, 204, UINT16_MAX, 204, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16589, UINT16_MAX, 207, UINT16_MAX, 207, 2881, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 208, UINT16_MAX, 208, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16593, UINT16_MAX, 211, UINT16_MAX, 211, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16596, UINT16_MAX, 214, UINT16_MAX, 214, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16599, UINT16_MAX, 217, UINT16_MAX, 217, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16602, UINT16_MAX, 220, UINT16_MAX, 220, 3510, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16605, UINT16_MAX, 223, UINT16_MAX, 223, 1606, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16608, UINT16_MAX, 226, UINT16_MAX, 226, 1594, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 227, UINT16_MAX, 227, 1588, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16612, UINT16_MAX, 230, UINT16_MAX, 230, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16615, UINT16_MAX, 233, UINT16_MAX, 233, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16618, UINT16_MAX, 236, UINT16_MAX, 236, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16621, UINT16_MAX, 239, UINT16_MAX, 239, 1523, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16624, UINT16_MAX, 242, UINT16_MAX, 242, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 243, UINT16_MAX, 243, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16628, UINT16_MAX, 246, UINT16_MAX, 246, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16631, 249, UINT16_MAX, 249, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16634, UINT16_MAX, 252, UINT16_MAX, 252, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16637, 255, UINT16_MAX, 255, UINT16_MAX, 3259, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16640, UINT16_MAX, 258, UINT16_MAX, 258, 3308, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16643, 261, UINT16_MAX, 261, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16646, UINT16_MAX, 264, UINT16_MAX, 264, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16649, 267, UINT16_MAX, 267, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16652, UINT16_MAX, 270, UINT16_MAX, 270, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16655, 273, UINT16_MAX, 273, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16658, UINT16_MAX, 276, UINT16_MAX, 276, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16661, 279, UINT16_MAX, 279, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16664, UINT16_MAX, 282, UINT16_MAX, 282, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16667, 285, UINT16_MAX, 285, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16670, UINT16_MAX, 288, UINT16_MAX, 288, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16673, 291, UINT16_MAX, 291, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16676, UINT16_MAX, 294, UINT16_MAX, 294, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 295, UINT16_MAX, 295, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 296, UINT16_MAX, 296, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16681, 299, UINT16_MAX, 299, UINT16_MAX, 2858, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16684, UINT16_MAX, 302, UINT16_MAX, 302, 2862, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16687, 305, UINT16_MAX, 305, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16690, UINT16_MAX, 308, UINT16_MAX, 308, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16693, 311, UINT16_MAX, 311, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16696, UINT16_MAX, 314, UINT16_MAX, 314, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16699, 317, UINT16_MAX, 317, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16702, UINT16_MAX, 320, UINT16_MAX, 320, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16705, 323, UINT16_MAX, 323, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16708, UINT16_MAX, 326, UINT16_MAX, 326, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16711, 329, UINT16_MAX, 329, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16714, UINT16_MAX, 332, UINT16_MAX, 332, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16717, 335, UINT16_MAX, 335, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16720, UINT16_MAX, 338, UINT16_MAX, 338, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16723, 341, UINT16_MAX, 341, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16726, UINT16_MAX, 344, UINT16_MAX, 344, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16729, 347, UINT16_MAX, 347, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16732, UINT16_MAX, 350, UINT16_MAX, 350, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16735, 353, UINT16_MAX, 353, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16738, UINT16_MAX, 356, UINT16_MAX, 356, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 357, UINT16_MAX, 357, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 358, UINT16_MAX, 358, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16743, 361, UINT16_MAX, 361, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16746, UINT16_MAX, 364, UINT16_MAX, 364, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16749, 367, UINT16_MAX, 367, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16752, UINT16_MAX, 370, UINT16_MAX, 370, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16755, 373, UINT16_MAX, 373, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16758, UINT16_MAX, 376, UINT16_MAX, 376, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16761, 379, UINT16_MAX, 379, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16764, UINT16_MAX, 382, UINT16_MAX, 382, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16767, 16769, UINT16_MAX, 8, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 34, UINT16_MAX, 34, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 16771, 389, UINT16_MAX, 389, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 16774, UINT16_MAX, 392, UINT16_MAX, 392, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16777, 395, UINT16_MAX, 395, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16780, UINT16_MAX, 398, UINT16_MAX, 398, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16783, 401, UINT16_MAX, 401, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16786, UINT16_MAX, 404, UINT16_MAX, 404, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 405, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16790, 408, UINT16_MAX, 408, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16793, UINT16_MAX, 411, UINT16_MAX, 411, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16796, 414, UINT16_MAX, 414, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16799, UINT16_MAX, 417, UINT16_MAX, 417, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16802, 420, UINT16_MAX, 420, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16805, UINT16_MAX, 423, UINT16_MAX, 423, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 16808, 426, UINT16_MAX, 426, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 16811, UINT16_MAX, 429, UINT16_MAX, 429, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 430, UINT16_MAX, 430, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 431, UINT16_MAX, 431, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16816, 434, UINT16_MAX, 434, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16819, UINT16_MAX, 437, UINT16_MAX, 437, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16822, 440, UINT16_MAX, 440, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16825, UINT16_MAX, 443, UINT16_MAX, 443, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16828, 446, UINT16_MAX, 446, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16831, UINT16_MAX, 449, UINT16_MAX, 449, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 16834, 16834, 452, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 453, UINT16_MAX, 453, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 454, UINT16_MAX, 454, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16839, 457, UINT16_MAX, 457, UINT16_MAX, 2974, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16842, UINT16_MAX, 460, UINT16_MAX, 460, 2978, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16845, 463, UINT16_MAX, 463, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16848, UINT16_MAX, 466, UINT16_MAX, 466, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16851, 469, UINT16_MAX, 469, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16854, UINT16_MAX, 472, UINT16_MAX, 472, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 473, UINT16_MAX, 473, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 474, UINT16_MAX, 474, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16859, 477, UINT16_MAX, 477, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16862, UINT16_MAX, 480, UINT16_MAX, 480, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16865, 483, UINT16_MAX, 483, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16868, UINT16_MAX, 486, UINT16_MAX, 486, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16871, 489, UINT16_MAX, 489, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16874, UINT16_MAX, 492, UINT16_MAX, 492, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16877, 495, UINT16_MAX, 495, UINT16_MAX, 3012, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16880, UINT16_MAX, 498, UINT16_MAX, 498, 3015, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16883, 501, UINT16_MAX, 501, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16886, UINT16_MAX, 504, UINT16_MAX, 504, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16889, 507, UINT16_MAX, 507, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16892, UINT16_MAX, 510, UINT16_MAX, 510, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16895, 513, UINT16_MAX, 513, UINT16_MAX, 3018, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16898, UINT16_MAX, 516, UINT16_MAX, 516, 3021, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16901, 519, UINT16_MAX, 519, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16904, UINT16_MAX, 522, UINT16_MAX, 522, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16907, 525, UINT16_MAX, 525, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16910, UINT16_MAX, 528, UINT16_MAX, 528, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 529, UINT16_MAX, 529, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 530, UINT16_MAX, 530, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16915, 533, UINT16_MAX, 533, UINT16_MAX, 3030, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16918, UINT16_MAX, 536, UINT16_MAX, 536, 3033, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16921, 539, UINT16_MAX, 539, UINT16_MAX, 3036, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16924, UINT16_MAX, 542, UINT16_MAX, 542, 3039, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16927, 545, UINT16_MAX, 545, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16930, UINT16_MAX, 548, UINT16_MAX, 548, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16933, 551, UINT16_MAX, 551, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16936, UINT16_MAX, 554, UINT16_MAX, 554, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16939, 557, UINT16_MAX, 557, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16942, UINT16_MAX, 560, UINT16_MAX, 560, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16945, 563, UINT16_MAX, 563, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16948, UINT16_MAX, 566, UINT16_MAX, 566, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16951, 569, UINT16_MAX, 569, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16954, UINT16_MAX, 572, UINT16_MAX, 572, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16957, 575, UINT16_MAX, 575, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16960, UINT16_MAX, 578, UINT16_MAX, 578, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16963, 581, UINT16_MAX, 581, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16966, 584, UINT16_MAX, 584, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16969, UINT16_MAX, 587, UINT16_MAX, 587, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16972, 590, UINT16_MAX, 590, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16975, UINT16_MAX, 593, UINT16_MAX, 593, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 16978, 596, UINT16_MAX, 596, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 16981, UINT16_MAX, 599, UINT16_MAX, 599, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 18, 18, 44, UINT16_MAX, 44, 3140, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 600, UINT16_MAX, 600, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 601, UINT16_MAX, 601, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 602, UINT16_MAX, 602, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 603, UINT16_MAX, 603, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 604, UINT16_MAX, 604, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 605, UINT16_MAX, 605, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 606, UINT16_MAX, 606, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 607, UINT16_MAX, 607, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 608, UINT16_MAX, 608, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 609, UINT16_MAX, 609, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 610, UINT16_MAX, 610, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 611, UINT16_MAX, 611, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 612, UINT16_MAX, 612, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 613, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 614, UINT16_MAX, 614, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 615, UINT16_MAX, 615, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 616, UINT16_MAX, 616, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 617, UINT16_MAX, 617, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 618, UINT16_MAX, 618, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 619, UINT16_MAX, 619, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 620, UINT16_MAX, 620, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 621, UINT16_MAX, 621, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 622, UINT16_MAX, 622, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 623, UINT16_MAX, 623, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 624, UINT16_MAX, 624, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 625, UINT16_MAX, 625, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 626, UINT16_MAX, 626, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 627, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 628, UINT16_MAX, 628, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 629, UINT16_MAX, 629, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 630, UINT16_MAX, 630, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 631, UINT16_MAX, 631, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17016, 634, UINT16_MAX, 634, UINT16_MAX, 3565, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17019, UINT16_MAX, 637, UINT16_MAX, 637, 3614, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 638, UINT16_MAX, 638, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 639, UINT16_MAX, 639, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 640, UINT16_MAX, 640, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 641, UINT16_MAX, 641, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 642, UINT16_MAX, 642, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 643, UINT16_MAX, 643, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 644, UINT16_MAX, 644, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 645, UINT16_MAX, 645, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 646, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 647, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 648, UINT16_MAX, 648, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 649, UINT16_MAX, 649, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 650, UINT16_MAX, 650, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17035, 653, UINT16_MAX, 653, UINT16_MAX, 3663, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17038, UINT16_MAX, 656, UINT16_MAX, 656, 3712, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 657, UINT16_MAX, 657, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 658, UINT16_MAX, 658, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 659, UINT16_MAX, 659, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 660, UINT16_MAX, 660, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 661, UINT16_MAX, 661, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 662, UINT16_MAX, 662, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 663, UINT16_MAX, 663, UINT16_MAX, 1573, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 664, UINT16_MAX, 664, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 665, UINT16_MAX, 665, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 666, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 667, UINT16_MAX, 667, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 668, UINT16_MAX, 668, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 669, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 670, UINT16_MAX, 670, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 17055, 673, UINT16_MAX, 673, 674, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 17059, 673, 677, 673, 674, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 17062, UINT16_MAX, 677, UINT16_MAX, 674, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 17064, 682, UINT16_MAX, 682, 683, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 17068, 682, 686, 682, 683, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 17071, UINT16_MAX, 686, UINT16_MAX, 683, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 17073, 691, UINT16_MAX, 691, 692, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 17077, 691, 695, 691, 692, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 17080, UINT16_MAX, 695, UINT16_MAX, 692, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17082, 700, UINT16_MAX, 700, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17085, UINT16_MAX, 703, UINT16_MAX, 703, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17088, 706, UINT16_MAX, 706, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17091, UINT16_MAX, 709, UINT16_MAX, 709, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17094, 712, UINT16_MAX, 712, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17097, UINT16_MAX, 715, UINT16_MAX, 715, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17100, 718, UINT16_MAX, 718, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17103, UINT16_MAX, 721, UINT16_MAX, 721, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17106, 724, UINT16_MAX, 724, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17109, UINT16_MAX, 727, UINT16_MAX, 727, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17112, 730, UINT16_MAX, 730, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17115, UINT16_MAX, 733, UINT16_MAX, 733, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17118, 736, UINT16_MAX, 736, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17121, UINT16_MAX, 739, UINT16_MAX, 739, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17124, 742, UINT16_MAX, 742, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17127, UINT16_MAX, 745, UINT16_MAX, 745, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 746, UINT16_MAX, 746, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17131, 749, UINT16_MAX, 749, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17134, UINT16_MAX, 752, UINT16_MAX, 752, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17137, 755, UINT16_MAX, 755, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17140, UINT16_MAX, 758, UINT16_MAX, 758, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17143, 761, UINT16_MAX, 761, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17146, UINT16_MAX, 764, UINT16_MAX, 764, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 765, UINT16_MAX, 765, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 766, UINT16_MAX, 766, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17151, 769, UINT16_MAX, 769, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17154, UINT16_MAX, 772, UINT16_MAX, 772, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17157, 775, UINT16_MAX, 775, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17160, UINT16_MAX, 778, UINT16_MAX, 778, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17163, 781, UINT16_MAX, 781, UINT16_MAX, 1567, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17166, UINT16_MAX, 784, UINT16_MAX, 784, 1570, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17169, 787, UINT16_MAX, 787, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17172, UINT16_MAX, 790, UINT16_MAX, 790, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17175, 793, UINT16_MAX, 793, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17178, UINT16_MAX, 796, UINT16_MAX, 796, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17181, 17181, 799, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 17184, 802, UINT16_MAX, 802, 803, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 17188, 802, 806, 802, 803, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 17191, UINT16_MAX, 806, UINT16_MAX, 803, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17193, 811, UINT16_MAX, 811, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17196, UINT16_MAX, 814, UINT16_MAX, 814, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 815, UINT16_MAX, 815, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 816, UINT16_MAX, 816, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17201, 819, UINT16_MAX, 819, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17204, UINT16_MAX, 822, UINT16_MAX, 822, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17207, 825, UINT16_MAX, 825, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17210, UINT16_MAX, 828, UINT16_MAX, 828, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17213, 831, UINT16_MAX, 831, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17216, UINT16_MAX, 834, UINT16_MAX, 834, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17219, 837, UINT16_MAX, 837, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17222, UINT16_MAX, 840, UINT16_MAX, 840, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17225, 843, UINT16_MAX, 843, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17228, UINT16_MAX, 846, UINT16_MAX, 846, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17231, 849, UINT16_MAX, 849, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17234, UINT16_MAX, 852, UINT16_MAX, 852, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17237, 855, UINT16_MAX, 855, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17240, UINT16_MAX, 858, UINT16_MAX, 858, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17243, 861, UINT16_MAX, 861, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17246, UINT16_MAX, 864, UINT16_MAX, 864, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17249, 867, UINT16_MAX, 867, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17252, UINT16_MAX, 870, UINT16_MAX, 870, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17255, 873, UINT16_MAX, 873, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17258, UINT16_MAX, 876, UINT16_MAX, 876, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17261, 879, UINT16_MAX, 879, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17264, UINT16_MAX, 882, UINT16_MAX, 882, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17267, 885, UINT16_MAX, 885, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17270, UINT16_MAX, 888, UINT16_MAX, 888, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17273, 891, UINT16_MAX, 891, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17276, UINT16_MAX, 894, UINT16_MAX, 894, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17279, 897, UINT16_MAX, 897, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17282, UINT16_MAX, 900, UINT16_MAX, 900, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17285, 903, UINT16_MAX, 903, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17288, UINT16_MAX, 906, UINT16_MAX, 906, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17291, 909, UINT16_MAX, 909, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17294, UINT16_MAX, 912, UINT16_MAX, 912, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17297, 915, UINT16_MAX, 915, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17300, UINT16_MAX, 918, UINT16_MAX, 918, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17303, 921, UINT16_MAX, 921, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17306, UINT16_MAX, 924, UINT16_MAX, 924, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 925, UINT16_MAX, 925, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 926, UINT16_MAX, 926, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17311, 929, UINT16_MAX, 929, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17314, UINT16_MAX, 932, UINT16_MAX, 932, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 933, UINT16_MAX, 933, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 934, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 935, UINT16_MAX, 935, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 936, UINT16_MAX, 936, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 937, UINT16_MAX, 937, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 938, UINT16_MAX, 938, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17323, 941, UINT16_MAX, 941, UINT16_MAX, 1543, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17326, UINT16_MAX, 944, UINT16_MAX, 944, 1546, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17329, 947, UINT16_MAX, 947, UINT16_MAX, 2866, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17332, UINT16_MAX, 950, UINT16_MAX, 950, 2869, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17335, 953, UINT16_MAX, 953, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17338, UINT16_MAX, 956, UINT16_MAX, 956, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17341, 959, UINT16_MAX, 959, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17344, UINT16_MAX, 962, UINT16_MAX, 962, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17347, 965, UINT16_MAX, 965, UINT16_MAX, 1615, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17350, UINT16_MAX, 968, UINT16_MAX, 968, 1618, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17353, 971, UINT16_MAX, 971, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17356, UINT16_MAX, 974, UINT16_MAX, 974, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17359, 977, UINT16_MAX, 977, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17362, UINT16_MAX, 980, UINT16_MAX, 980, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 981, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 982, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 983, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 984, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 985, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 986, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 987, UINT16_MAX, 987, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 988, UINT16_MAX, 988, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 989, UINT16_MAX, 989, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 990, UINT16_MAX, 990, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 991, UINT16_MAX, 991, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 992, UINT16_MAX, 992, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 993, UINT16_MAX, 993, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 994, UINT16_MAX, 994, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 995, UINT16_MAX, 995, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 996, UINT16_MAX, 996, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 997, UINT16_MAX, 997, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 998, UINT16_MAX, 998, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 999, UINT16_MAX, 999, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1000, UINT16_MAX, 1000, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1001, UINT16_MAX, 1001, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1002, UINT16_MAX, 1002, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1003, UINT16_MAX, 1003, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1004, UINT16_MAX, 1004, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1005, UINT16_MAX, 1005, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1006, UINT16_MAX, 1006, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1007, UINT16_MAX, 1007, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1008, UINT16_MAX, 1008, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1009, UINT16_MAX, 1009, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1010, UINT16_MAX, 1010, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1011, UINT16_MAX, 1011, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1012, UINT16_MAX, 1012, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1013, UINT16_MAX, 1013, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1014, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1015, UINT16_MAX, 1015, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1016, UINT16_MAX, 1016, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1017, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1018, UINT16_MAX, 1018, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1019, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1020, UINT16_MAX, 1020, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1021, UINT16_MAX, 1021, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1022, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1023, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1024, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1025, UINT16_MAX, 1025, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1026, UINT16_MAX, 1026, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1027, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1028, UINT16_MAX, 1028, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1029, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1030, UINT16_MAX, 1030, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1031, UINT16_MAX, 1031, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1032, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1033, UINT16_MAX, 1033, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1034, UINT16_MAX, 1034, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1035, UINT16_MAX, 1035, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1036, UINT16_MAX, 1036, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1037, UINT16_MAX, 1037, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1038, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1039, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1040, UINT16_MAX, 1040, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1041, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1042, UINT16_MAX, 1042, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1043, UINT16_MAX, 1043, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1044, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1045, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1046, UINT16_MAX, 1046, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1047, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1048, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1049, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1050, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1051, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1052, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1053, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1054, UINT16_MAX, 1054, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1055, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1056, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1057, UINT16_MAX, 1057, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1058, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1059, UINT16_MAX, 1059, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1060, UINT16_MAX, 1060, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1061, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1062, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1063, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1064, UINT16_MAX, 1064, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1065, UINT16_MAX, 1065, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1066, UINT16_MAX, 1066, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1067, UINT16_MAX, 1067, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1068, UINT16_MAX, 1068, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1069, UINT16_MAX, 1069, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1070, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1071, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1072, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1073, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1074, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1075, UINT16_MAX, 1075, 1576, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1076, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1077, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1078, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1079, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1080, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1081, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1082, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1083, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1084, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1085, UINT16_MAX, 1085, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1086, UINT16_MAX, 1086, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1087, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1088, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1089, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1090, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1091, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1092, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1093, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1094, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1095, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1096, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1097, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1098, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1099, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1100, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1101, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1102, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1103, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 7, UINT16_MAX, 1104, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1105, UINT16_MAX, 1106, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 9, UINT16_MAX, 1107, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 17, UINT16_MAX, 1108, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1050, UINT16_MAX, 1109, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1052, UINT16_MAX, 1110, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1058, UINT16_MAX, 1111, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 22, UINT16_MAX, 1112, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 24, UINT16_MAX, 1113, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1114, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1115, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 17500, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 17502, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 17504, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 17506, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 17508, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 17510, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 620, UINT16_MAX, 1128, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 11, UINT16_MAX, 1129, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 18, UINT16_MAX, 1130, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 23, UINT16_MAX, 1131, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1077, UINT16_MAX, 1132, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32768, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32769, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32770, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32771, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32775, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32776, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32778, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32772, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32814, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32773, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32780, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32779, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32782, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32783, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32815, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32816, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 232, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 216, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32781, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 202, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32808, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32813, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32807, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32784, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 202, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32774, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 202, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32777, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32810, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32812, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32811, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32809, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 1, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 1, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32819, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, 1133, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, 1134, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32817, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, 1135, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, 17520, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 240, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, 1138, 1139, UINT16_MAX, 1139, 32818, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 233, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 234, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1140, UINT16_MAX, 1140, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1141, UINT16_MAX, 1141, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1142, UINT16_MAX, 1142, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1143, UINT16_MAX, 1143, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 1144, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1145, UINT16_MAX, 1145, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1146, UINT16_MAX, 1146, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 17531, UINT16_MAX, 1149, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1150, UINT16_MAX, 1150, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1151, UINT16_MAX, 1151, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1152, UINT16_MAX, 1152, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, 0, 1153, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1154, UINT16_MAX, 1154, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 17539, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17541, 1159, UINT16_MAX, 1159, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, 0, 1160, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17545, 1163, UINT16_MAX, 1163, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17548, 1166, UINT16_MAX, 1166, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17551, 1169, UINT16_MAX, 1169, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17554, 1172, UINT16_MAX, 1172, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17557, 1175, UINT16_MAX, 1175, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17560, 1178, UINT16_MAX, 1178, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17563, 33949, 1184, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1185, UINT16_MAX, 1185, UINT16_MAX, 1673, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1186, UINT16_MAX, 1186, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1187, UINT16_MAX, 1187, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1188, UINT16_MAX, 1188, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1189, UINT16_MAX, 1189, UINT16_MAX, 1726, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1190, UINT16_MAX, 1190, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1191, UINT16_MAX, 1191, UINT16_MAX, 1777, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1192, UINT16_MAX, 1192, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1138, UINT16_MAX, 1138, UINT16_MAX, 1830, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1193, UINT16_MAX, 1193, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1194, UINT16_MAX, 1194, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 62, UINT16_MAX, 62, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1195, UINT16_MAX, 1195, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1196, UINT16_MAX, 1196, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1197, UINT16_MAX, 1197, UINT16_MAX, 1881, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1198, UINT16_MAX, 1198, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1199, UINT16_MAX, 1199, UINT16_MAX, 5027, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1200, UINT16_MAX, 1200, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1201, UINT16_MAX, 1201, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1202, UINT16_MAX, 1202, UINT16_MAX, 1932, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1203, UINT16_MAX, 1203, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1204, UINT16_MAX, 1204, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1205, UINT16_MAX, 1205, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1206, UINT16_MAX, 1206, UINT16_MAX, 1983, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17591, 1209, UINT16_MAX, 1209, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17594, 1212, UINT16_MAX, 1212, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17597, UINT16_MAX, 1215, UINT16_MAX, 1215, 4904, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17600, UINT16_MAX, 1218, UINT16_MAX, 1218, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17603, UINT16_MAX, 1221, UINT16_MAX, 1221, 4913, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17606, UINT16_MAX, 1224, UINT16_MAX, 1224, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17609, 33995, 1230, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1231, UINT16_MAX, 1231, 2088, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1232, UINT16_MAX, 1232, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1233, UINT16_MAX, 1233, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1234, UINT16_MAX, 1234, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1235, UINT16_MAX, 1235, 2141, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1236, UINT16_MAX, 1236, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1237, UINT16_MAX, 1237, 2192, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1238, UINT16_MAX, 1238, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1139, UINT16_MAX, 1139, 2245, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1239, UINT16_MAX, 1239, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1240, UINT16_MAX, 1240, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 63, UINT16_MAX, 63, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1241, UINT16_MAX, 1241, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1242, UINT16_MAX, 1242, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1243, UINT16_MAX, 1243, 2401, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1244, UINT16_MAX, 1244, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1245, UINT16_MAX, 1245, 5023, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1200, 1246, UINT16_MAX, 1246, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1246, UINT16_MAX, 1246, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1247, UINT16_MAX, 1247, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1248, UINT16_MAX, 1248, 2349, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1249, UINT16_MAX, 1249, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1250, UINT16_MAX, 1250, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1251, UINT16_MAX, 1251, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1252, UINT16_MAX, 1252, 2452, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17637, UINT16_MAX, 1255, UINT16_MAX, 1255, 2036, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17640, UINT16_MAX, 1258, UINT16_MAX, 1258, 2297, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17643, UINT16_MAX, 1261, UINT16_MAX, 1261, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17646, UINT16_MAX, 1264, UINT16_MAX, 1264, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17649, UINT16_MAX, 1267, UINT16_MAX, 1267, 5033, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1268, UINT16_MAX, 1268, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1186, 1186, 1232, UINT16_MAX, 1232, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1192, 1192, 1238, UINT16_MAX, 1238, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1248, UINT16_MAX, UINT16_MAX, 1269, UINT16_MAX, 2505, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17654, UINT16_MAX, UINT16_MAX, 1272, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17657, UINT16_MAX, UINT16_MAX, 1275, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1203, 1203, 1249, UINT16_MAX, 1249, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1198, 1198, 1244, UINT16_MAX, 1244, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1276, UINT16_MAX, 1276, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1277, UINT16_MAX, 1277, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1278, UINT16_MAX, 1278, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1279, UINT16_MAX, 1279, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1280, UINT16_MAX, 1280, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1281, UINT16_MAX, 1281, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1282, UINT16_MAX, 1282, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1283, UINT16_MAX, 1283, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1284, UINT16_MAX, 1284, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1285, UINT16_MAX, 1285, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1286, UINT16_MAX, 1286, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1287, UINT16_MAX, 1287, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1288, UINT16_MAX, 1288, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1289, UINT16_MAX, 1289, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1290, UINT16_MAX, 1290, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1291, UINT16_MAX, 1291, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1292, UINT16_MAX, 1292, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1293, UINT16_MAX, 1293, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1294, UINT16_MAX, 1294, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1295, UINT16_MAX, 1295, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1296, UINT16_MAX, 1296, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1297, UINT16_MAX, 1297, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1298, UINT16_MAX, 1298, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1299, UINT16_MAX, 1299, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1300, UINT16_MAX, 1300, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1193, 1193, 1239, UINT16_MAX, 1239, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1199, 1199, 1245, UINT16_MAX, 1245, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1301, UINT16_MAX, 1302, UINT16_MAX, 1302, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1303, UINT16_MAX, 1303, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1238, 1192, UINT16_MAX, 1192, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1189, 1189, 1235, UINT16_MAX, 1235, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1304, UINT16_MAX, 1304, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1305, UINT16_MAX, 1305, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1246, 1306, UINT16_MAX, 1306, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1307, UINT16_MAX, 1307, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1308, UINT16_MAX, 1308, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1309, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1310, UINT16_MAX, 1310, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1311, UINT16_MAX, 1311, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1312, UINT16_MAX, 1312, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17697, 1315, UINT16_MAX, 1315, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17700, 1318, UINT16_MAX, 1318, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1319, UINT16_MAX, 1319, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17704, 1322, UINT16_MAX, 1322, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1323, UINT16_MAX, 1323, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1324, UINT16_MAX, 1324, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1325, UINT16_MAX, 1325, UINT16_MAX, 2525, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17710, 1328, UINT16_MAX, 1328, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1329, UINT16_MAX, 1329, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1330, UINT16_MAX, 1330, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1331, UINT16_MAX, 1331, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1332, UINT16_MAX, 1332, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17717, 1335, UINT16_MAX, 1335, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17720, 1338, UINT16_MAX, 1338, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17723, 1341, UINT16_MAX, 1341, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1342, UINT16_MAX, 1342, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1343, UINT16_MAX, 1343, UINT16_MAX, 2615, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1344, UINT16_MAX, 1344, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1345, UINT16_MAX, 1345, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1346, UINT16_MAX, 1346, UINT16_MAX, 2522, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1347, UINT16_MAX, 1347, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1348, UINT16_MAX, 1348, UINT16_MAX, 2511, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1349, UINT16_MAX, 1349, UINT16_MAX, 2601, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1350, UINT16_MAX, 1350, UINT16_MAX, 2635, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1351, UINT16_MAX, 1351, UINT16_MAX, 2531, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17736, 1354, UINT16_MAX, 1354, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1355, UINT16_MAX, 1355, UINT16_MAX, 2528, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1356, UINT16_MAX, 1356, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1357, UINT16_MAX, 1357, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1358, UINT16_MAX, 1358, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1359, UINT16_MAX, 1359, UINT16_MAX, 2641, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1360, UINT16_MAX, 1360, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1361, UINT16_MAX, 1361, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1362, UINT16_MAX, 1362, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1363, UINT16_MAX, 1363, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1364, UINT16_MAX, 1364, UINT16_MAX, 2542, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1365, UINT16_MAX, 1365, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1366, UINT16_MAX, 1366, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1367, UINT16_MAX, 1367, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1368, UINT16_MAX, 1368, UINT16_MAX, 2659, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1369, UINT16_MAX, 1369, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1370, UINT16_MAX, 1370, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1371, UINT16_MAX, 1371, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1372, UINT16_MAX, 1372, UINT16_MAX, 2665, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1373, UINT16_MAX, 1373, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1374, UINT16_MAX, 1374, UINT16_MAX, 2653, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1375, UINT16_MAX, 1375, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1376, UINT16_MAX, 1376, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1377, UINT16_MAX, 1377, 2622, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1378, UINT16_MAX, 1378, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1379, UINT16_MAX, 1379, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1380, UINT16_MAX, 1380, 2575, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1381, UINT16_MAX, 1381, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1382, UINT16_MAX, 1382, 2564, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1383, UINT16_MAX, 1383, 2608, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1384, UINT16_MAX, 1384, 2638, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1385, UINT16_MAX, 1385, 2553, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17770, UINT16_MAX, 1388, UINT16_MAX, 1388, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1389, UINT16_MAX, 1389, 2581, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1390, UINT16_MAX, 1390, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1391, UINT16_MAX, 1391, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1392, UINT16_MAX, 1392, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1393, UINT16_MAX, 1393, 2644, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1394, UINT16_MAX, 1394, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1395, UINT16_MAX, 1395, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1396, UINT16_MAX, 1396, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1397, UINT16_MAX, 1397, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1398, UINT16_MAX, 1398, 2584, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1399, UINT16_MAX, 1399, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1400, UINT16_MAX, 1400, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1401, UINT16_MAX, 1401, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1402, UINT16_MAX, 1402, 2662, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1403, UINT16_MAX, 1403, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1404, UINT16_MAX, 1404, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1405, UINT16_MAX, 1405, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1406, UINT16_MAX, 1406, 2668, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1407, UINT16_MAX, 1407, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1408, UINT16_MAX, 1408, 2656, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1409, UINT16_MAX, 1409, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1410, UINT16_MAX, 1410, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17795, UINT16_MAX, 1413, UINT16_MAX, 1413, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17798, UINT16_MAX, 1416, UINT16_MAX, 1416, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1417, UINT16_MAX, 1417, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17802, UINT16_MAX, 1420, UINT16_MAX, 1420, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1421, UINT16_MAX, 1421, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1422, UINT16_MAX, 1422, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1423, UINT16_MAX, 1423, 2578, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17808, UINT16_MAX, 1426, UINT16_MAX, 1426, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1427, UINT16_MAX, 1427, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1428, UINT16_MAX, 1428, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1429, UINT16_MAX, 1429, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1430, UINT16_MAX, 1430, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17815, UINT16_MAX, 1433, UINT16_MAX, 1433, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17818, UINT16_MAX, 1436, UINT16_MAX, 1436, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17821, UINT16_MAX, 1439, UINT16_MAX, 1439, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1440, UINT16_MAX, 1440, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1441, UINT16_MAX, 1441, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1442, UINT16_MAX, 1442, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1443, UINT16_MAX, 1443, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1444, UINT16_MAX, 1444, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1445, UINT16_MAX, 1445, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1446, UINT16_MAX, 1446, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1447, UINT16_MAX, 1447, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1448, UINT16_MAX, 1448, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1449, UINT16_MAX, 1449, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1450, UINT16_MAX, 1450, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1451, UINT16_MAX, 1451, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1452, UINT16_MAX, 1452, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1453, UINT16_MAX, 1453, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1454, UINT16_MAX, 1454, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1455, UINT16_MAX, 1455, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1456, UINT16_MAX, 1456, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1457, UINT16_MAX, 1457, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1458, UINT16_MAX, 1458, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1459, UINT16_MAX, 1459, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1460, UINT16_MAX, 1460, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1461, UINT16_MAX, 1461, UINT16_MAX, 2595, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1462, UINT16_MAX, 1462, 2598, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17847, 1465, UINT16_MAX, 1465, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17850, UINT16_MAX, 1468, UINT16_MAX, 1468, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1469, UINT16_MAX, 1469, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1470, UINT16_MAX, 1470, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1471, UINT16_MAX, 1471, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1472, UINT16_MAX, 1472, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1473, UINT16_MAX, 1473, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1474, UINT16_MAX, 1474, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1475, UINT16_MAX, 1475, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1476, UINT16_MAX, 1476, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1477, UINT16_MAX, 1477, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1478, UINT16_MAX, 1478, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ME, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1479, UINT16_MAX, 1479, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1480, UINT16_MAX, 1480, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1481, UINT16_MAX, 1481, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1482, UINT16_MAX, 1482, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1483, UINT16_MAX, 1483, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1484, UINT16_MAX, 1484, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1485, UINT16_MAX, 1485, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1486, UINT16_MAX, 1486, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1487, UINT16_MAX, 1487, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1488, UINT16_MAX, 1488, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1489, UINT16_MAX, 1489, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1490, UINT16_MAX, 1490, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1491, UINT16_MAX, 1491, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1492, UINT16_MAX, 1492, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1493, UINT16_MAX, 1493, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1494, UINT16_MAX, 1494, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1495, UINT16_MAX, 1495, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1496, UINT16_MAX, 1496, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1497, UINT16_MAX, 1497, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1498, UINT16_MAX, 1498, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1499, UINT16_MAX, 1499, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1500, UINT16_MAX, 1500, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1501, UINT16_MAX, 1501, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1502, UINT16_MAX, 1502, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1503, UINT16_MAX, 1503, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1504, UINT16_MAX, 1504, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1505, UINT16_MAX, 1505, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1506, UINT16_MAX, 1506, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1507, UINT16_MAX, 1507, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1508, UINT16_MAX, 1508, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1509, UINT16_MAX, 1509, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1510, UINT16_MAX, 1510, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1511, UINT16_MAX, 1511, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1512, UINT16_MAX, 1512, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1513, UINT16_MAX, 1513, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1514, UINT16_MAX, 1514, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1515, UINT16_MAX, 1515, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1516, UINT16_MAX, 1516, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1517, UINT16_MAX, 1517, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1518, UINT16_MAX, 1518, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1519, UINT16_MAX, 1519, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1520, UINT16_MAX, 1520, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1521, UINT16_MAX, 1521, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1522, UINT16_MAX, 1522, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1523, UINT16_MAX, 1523, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1524, UINT16_MAX, 1524, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1525, UINT16_MAX, 1525, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1526, UINT16_MAX, 1526, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1527, UINT16_MAX, 1527, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1528, UINT16_MAX, 1528, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1529, UINT16_MAX, 1529, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1530, UINT16_MAX, 1530, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1531, UINT16_MAX, 1531, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1532, UINT16_MAX, 1532, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1533, UINT16_MAX, 1533, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17918, 1536, UINT16_MAX, 1536, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17921, UINT16_MAX, 1539, UINT16_MAX, 1539, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1540, UINT16_MAX, 1540, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1541, UINT16_MAX, 1541, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1542, UINT16_MAX, 1542, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1543, UINT16_MAX, 1543, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1544, UINT16_MAX, 1544, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1545, UINT16_MAX, 1545, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1546, UINT16_MAX, 1546, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1547, UINT16_MAX, 1547, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1548, UINT16_MAX, 1548, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1549, UINT16_MAX, 1549, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1550, UINT16_MAX, 1550, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1551, UINT16_MAX, 1551, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1552, UINT16_MAX, 1552, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17937, 1555, UINT16_MAX, 1555, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17940, UINT16_MAX, 1558, UINT16_MAX, 1558, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17943, 1561, UINT16_MAX, 1561, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17946, UINT16_MAX, 1564, UINT16_MAX, 1564, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1565, UINT16_MAX, 1565, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1566, UINT16_MAX, 1566, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17951, 1569, UINT16_MAX, 1569, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17954, UINT16_MAX, 1572, UINT16_MAX, 1572, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1573, UINT16_MAX, 1573, UINT16_MAX, 2629, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1574, UINT16_MAX, 1574, 2632, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17959, 1577, UINT16_MAX, 1577, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17962, UINT16_MAX, 1580, UINT16_MAX, 1580, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17965, 1583, UINT16_MAX, 1583, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17968, UINT16_MAX, 1586, UINT16_MAX, 1586, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17971, 1589, UINT16_MAX, 1589, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17974, UINT16_MAX, 1592, UINT16_MAX, 1592, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1593, UINT16_MAX, 1593, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1594, UINT16_MAX, 1594, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17979, 1597, UINT16_MAX, 1597, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17982, UINT16_MAX, 1600, UINT16_MAX, 1600, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17985, 1603, UINT16_MAX, 1603, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17988, UINT16_MAX, 1606, UINT16_MAX, 1606, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17991, 1609, UINT16_MAX, 1609, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 17994, UINT16_MAX, 1612, UINT16_MAX, 1612, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1613, UINT16_MAX, 1613, UINT16_MAX, 2647, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1614, UINT16_MAX, 1614, 2650, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 17999, 1617, UINT16_MAX, 1617, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18002, UINT16_MAX, 1620, UINT16_MAX, 1620, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18005, 1623, UINT16_MAX, 1623, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18008, UINT16_MAX, 1626, UINT16_MAX, 1626, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18011, 1629, UINT16_MAX, 1629, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18014, UINT16_MAX, 1632, UINT16_MAX, 1632, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18017, 1635, UINT16_MAX, 1635, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18020, UINT16_MAX, 1638, UINT16_MAX, 1638, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18023, 1641, UINT16_MAX, 1641, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18026, UINT16_MAX, 1644, UINT16_MAX, 1644, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18029, 1647, UINT16_MAX, 1647, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18032, UINT16_MAX, 1650, UINT16_MAX, 1650, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1651, UINT16_MAX, 1651, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1652, UINT16_MAX, 1652, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18037, 1655, UINT16_MAX, 1655, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18040, UINT16_MAX, 1658, UINT16_MAX, 1658, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1659, UINT16_MAX, 1659, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1660, UINT16_MAX, 1660, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1661, UINT16_MAX, 1661, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1662, UINT16_MAX, 1662, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1663, UINT16_MAX, 1663, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1664, UINT16_MAX, 1664, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1665, UINT16_MAX, 1665, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1666, UINT16_MAX, 1666, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1667, UINT16_MAX, 1667, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1668, UINT16_MAX, 1668, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1669, UINT16_MAX, 1669, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1670, UINT16_MAX, 1670, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1671, UINT16_MAX, 1671, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1672, UINT16_MAX, 1672, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1673, UINT16_MAX, 1673, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1674, UINT16_MAX, 1674, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1675, UINT16_MAX, 1675, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1676, UINT16_MAX, 1676, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1677, UINT16_MAX, 1677, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1678, UINT16_MAX, 1678, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1679, UINT16_MAX, 1679, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1680, UINT16_MAX, 1680, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1681, UINT16_MAX, 1681, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1682, UINT16_MAX, 1682, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1683, UINT16_MAX, 1683, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1684, UINT16_MAX, 1684, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1685, UINT16_MAX, 1685, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1686, UINT16_MAX, 1686, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1687, UINT16_MAX, 1687, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1688, UINT16_MAX, 1688, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1689, UINT16_MAX, 1689, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1690, UINT16_MAX, 1690, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1691, UINT16_MAX, 1691, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1692, UINT16_MAX, 1692, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1693, UINT16_MAX, 1693, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1694, UINT16_MAX, 1694, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1695, UINT16_MAX, 1695, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1696, UINT16_MAX, 1696, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1697, UINT16_MAX, 1697, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1698, UINT16_MAX, 1698, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1699, UINT16_MAX, 1699, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1700, UINT16_MAX, 1700, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1701, UINT16_MAX, 1701, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1702, UINT16_MAX, 1702, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1703, UINT16_MAX, 1703, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1704, UINT16_MAX, 1704, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1705, UINT16_MAX, 1705, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1706, UINT16_MAX, 1706, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1707, UINT16_MAX, 1707, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1708, UINT16_MAX, 1708, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1709, UINT16_MAX, 1709, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1710, UINT16_MAX, 1710, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1711, UINT16_MAX, 1711, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1712, UINT16_MAX, 1712, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1713, UINT16_MAX, 1713, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1714, UINT16_MAX, 1714, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1715, UINT16_MAX, 1715, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1716, UINT16_MAX, 1716, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1717, UINT16_MAX, 1717, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1718, UINT16_MAX, 1718, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1719, UINT16_MAX, 1719, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1720, UINT16_MAX, 1720, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1721, UINT16_MAX, 1721, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1722, UINT16_MAX, 1722, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1723, UINT16_MAX, 1723, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1724, UINT16_MAX, 1724, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1725, UINT16_MAX, 1725, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1726, UINT16_MAX, 1726, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1727, UINT16_MAX, 1727, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1728, UINT16_MAX, 1728, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1729, UINT16_MAX, 1729, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1730, UINT16_MAX, 1730, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1731, UINT16_MAX, 1731, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1732, UINT16_MAX, 1732, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1733, UINT16_MAX, 1733, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1734, UINT16_MAX, 1734, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1735, UINT16_MAX, 1735, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1736, UINT16_MAX, 1736, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1737, UINT16_MAX, 1737, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1738, UINT16_MAX, 1738, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1739, UINT16_MAX, 1739, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1740, UINT16_MAX, 1740, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1741, UINT16_MAX, 1741, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1742, UINT16_MAX, 1742, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1743, UINT16_MAX, 1743, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1744, UINT16_MAX, 1744, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1745, UINT16_MAX, 1745, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1746, UINT16_MAX, 1746, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1747, UINT16_MAX, 1747, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1748, UINT16_MAX, 1748, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1749, UINT16_MAX, 1749, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1750, UINT16_MAX, 1750, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1751, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1752, UINT16_MAX, 1752, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1753, UINT16_MAX, 1753, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1754, UINT16_MAX, 1754, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1755, UINT16_MAX, 1755, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1756, UINT16_MAX, 1756, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1757, UINT16_MAX, 1757, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1758, UINT16_MAX, 1758, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1759, UINT16_MAX, 1759, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1760, UINT16_MAX, 1760, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1761, UINT16_MAX, 1761, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1762, UINT16_MAX, 1762, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1763, UINT16_MAX, 1763, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1764, UINT16_MAX, 1764, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1765, UINT16_MAX, 1765, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1766, UINT16_MAX, 1766, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1767, UINT16_MAX, 1767, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1768, UINT16_MAX, 1768, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1769, UINT16_MAX, 1769, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1770, UINT16_MAX, 1770, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1771, UINT16_MAX, 1771, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1772, UINT16_MAX, 1772, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1773, UINT16_MAX, 1773, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1774, UINT16_MAX, 1774, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1775, UINT16_MAX, 1775, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1776, UINT16_MAX, 1776, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1777, UINT16_MAX, 1777, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1778, UINT16_MAX, 1778, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1779, UINT16_MAX, 1779, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1780, UINT16_MAX, 1780, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1781, UINT16_MAX, 1781, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1782, UINT16_MAX, 1782, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1783, UINT16_MAX, 1783, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1784, UINT16_MAX, 1784, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1785, UINT16_MAX, 1785, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1786, UINT16_MAX, 1786, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1787, UINT16_MAX, 1787, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1788, UINT16_MAX, 1788, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1789, UINT16_MAX, 1789, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 18174, 18174, 1792, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1793, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 222, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 228, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 10, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 11, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 12, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 13, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 14, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 15, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 16, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 17, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 18, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 19, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 20, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 21, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 22, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 23, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 24, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 25, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_AN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_PREPEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 30, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 31, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 32, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 18178, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 18180, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 18182, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 18184, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 18186, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2671, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2676, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2679, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 27, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 28, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 29, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 33, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 34, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32785, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32786, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32787, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_AN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_AN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 35, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_COMPAT, 18188, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_COMPAT, 18190, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_COMPAT, 18192, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_COMPAT, 18194, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 18196, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2685, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 18198, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2688, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 18200, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2682, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_PREPEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 36, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2691, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18202, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2694, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18204, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2697, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18206, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT}, + {UTF8PROC_CATEGORY_MN, 7, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32788, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 9, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_LINKER}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18208, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18210, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18212, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18214, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18216, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18218, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18220, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18222, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT}, + {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 7, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32789, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2700, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18224, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18226, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32790, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18228, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18230, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18232, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18234, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18236, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 9, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18238, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18240, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18242, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18244, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32792, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2704, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18246, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18248, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18250, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32791, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32793, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18252, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18254, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_CONSONANT}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2709, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18256, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32795, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2712, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2716, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18258, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18260, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18262, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32794, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2719, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 18264, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 84, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 91, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32796, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2722, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18266, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32799, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2725, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18268, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18270, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18272, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2730, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18274, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32797, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32798, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 9, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32800, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2733, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2737, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18278, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18280, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_PREPEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32801, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 9, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32802, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32803, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2740, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18282, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18284, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2745, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18286, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18288, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32804, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 18290, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 103, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 107, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 18292, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 118, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 122, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 18294, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 18296, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NOBREAK, 1914, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 216, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18299, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18301, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18303, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18305, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18307, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18309, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 129, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 130, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 18311, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 132, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 18313, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 18315, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, UTF8PROC_DECOMP_TYPE_COMPAT, 18317, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 18319, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, UTF8PROC_DECOMP_TYPE_COMPAT, 18321, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 18323, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 18325, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 18327, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 18329, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 18331, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 18333, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 18335, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2748, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18337, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32805, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1955, UINT16_MAX, 1955, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1956, UINT16_MAX, 1956, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1957, UINT16_MAX, 1957, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1958, UINT16_MAX, 1958, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1959, UINT16_MAX, 1959, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1960, UINT16_MAX, 1960, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1961, UINT16_MAX, 1961, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1962, UINT16_MAX, 1962, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1963, UINT16_MAX, 1963, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1964, UINT16_MAX, 1964, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1965, UINT16_MAX, 1965, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1966, UINT16_MAX, 1966, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1967, UINT16_MAX, 1967, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1968, UINT16_MAX, 1968, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1969, UINT16_MAX, 1969, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1970, UINT16_MAX, 1970, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1971, UINT16_MAX, 1971, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1972, UINT16_MAX, 1972, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1973, UINT16_MAX, 1973, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1974, UINT16_MAX, 1974, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1975, UINT16_MAX, 1975, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1976, UINT16_MAX, 1976, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1977, UINT16_MAX, 1977, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1978, UINT16_MAX, 1978, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1979, UINT16_MAX, 1979, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1980, UINT16_MAX, 1980, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1981, UINT16_MAX, 1981, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1982, UINT16_MAX, 1982, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1983, UINT16_MAX, 1983, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1984, UINT16_MAX, 1984, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1985, UINT16_MAX, 1985, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1986, UINT16_MAX, 1986, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1987, UINT16_MAX, 1987, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1988, UINT16_MAX, 1988, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1989, UINT16_MAX, 1989, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1990, UINT16_MAX, 1990, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1991, UINT16_MAX, 1991, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1992, UINT16_MAX, 1992, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1993, UINT16_MAX, 1993, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1994, UINT16_MAX, 1994, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1995, UINT16_MAX, 1996, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1997, UINT16_MAX, 1998, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1999, UINT16_MAX, 2000, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2001, UINT16_MAX, 2002, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2003, UINT16_MAX, 2004, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2005, UINT16_MAX, 2006, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2007, UINT16_MAX, 2008, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2009, UINT16_MAX, 2010, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2011, UINT16_MAX, 2012, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2013, UINT16_MAX, 2014, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2015, UINT16_MAX, 2016, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2017, UINT16_MAX, 2018, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2019, UINT16_MAX, 2020, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2021, UINT16_MAX, 2022, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2023, UINT16_MAX, 2024, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2025, UINT16_MAX, 2026, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2027, UINT16_MAX, 2028, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2029, UINT16_MAX, 2030, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2031, UINT16_MAX, 2032, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2033, UINT16_MAX, 2034, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2035, UINT16_MAX, 2036, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2037, UINT16_MAX, 2038, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2039, UINT16_MAX, 2040, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2041, UINT16_MAX, 2042, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2043, UINT16_MAX, 2044, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2045, UINT16_MAX, 2046, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2047, UINT16_MAX, 2048, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2049, UINT16_MAX, 2050, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2051, UINT16_MAX, 2052, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2053, UINT16_MAX, 2054, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2055, UINT16_MAX, 2056, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2057, UINT16_MAX, 2058, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2059, UINT16_MAX, 2060, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2061, UINT16_MAX, 2062, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2063, UINT16_MAX, 2064, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2065, UINT16_MAX, 2066, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2067, UINT16_MAX, 2068, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2069, UINT16_MAX, 2070, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2071, UINT16_MAX, 2072, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2073, UINT16_MAX, 2074, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2075, UINT16_MAX, 2076, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2077, UINT16_MAX, 2078, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2079, UINT16_MAX, 2080, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2020, UINT16_MAX, 2081, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2082, UINT16_MAX, 2083, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2084, UINT16_MAX, 2085, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2086, UINT16_MAX, 2087, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_L, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, false, 2, 0, UTF8PROC_BOUNDCLASS_L, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, false, 1, 0, UTF8PROC_BOUNDCLASS_V, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_V, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_T, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2088, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2089, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2090, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2091, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2092, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2093, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2094, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2095, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2096, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2097, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2098, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2099, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2100, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2101, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2102, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2103, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2104, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2105, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2106, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2107, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2108, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2109, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2110, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2111, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2112, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2113, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2114, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2115, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2116, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2117, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2118, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2119, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2120, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2121, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2122, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2123, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2124, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2125, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2126, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2127, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2128, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2129, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2130, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2131, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2132, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2133, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2134, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2135, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2136, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2137, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2138, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2139, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2140, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2141, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2142, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2143, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2144, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2145, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2146, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2147, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2148, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2149, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2150, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2151, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2152, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2153, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2154, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2155, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2156, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2157, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2158, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2159, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2160, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2161, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2162, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2163, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2164, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2165, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2166, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2167, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2168, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2169, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2170, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2171, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2172, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2173, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2174, 2174, UINT16_MAX, 2174, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2175, 2175, UINT16_MAX, 2175, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2176, 2176, UINT16_MAX, 2176, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2177, 2177, UINT16_MAX, 2177, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2178, 2178, UINT16_MAX, 2178, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2179, 2179, UINT16_MAX, 2179, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 9, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_BN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2751, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18564, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2754, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18566, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2757, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18568, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2760, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18570, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2763, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18572, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2766, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 18574, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32806, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2769, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18576, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2772, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18578, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2775, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2778, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18580, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18582, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2781, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 18584, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1345, 1379, UINT16_MAX, 1379, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1347, 1381, UINT16_MAX, 1381, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1359, 1393, UINT16_MAX, 1393, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1362, 1396, UINT16_MAX, 1396, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1363, 1397, UINT16_MAX, 1397, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1371, 1405, UINT16_MAX, 1405, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1443, 1444, UINT16_MAX, 1444, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2202, 2203, UINT16_MAX, 2203, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1996, UINT16_MAX, 1996, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1998, UINT16_MAX, 1998, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2000, UINT16_MAX, 2000, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2002, UINT16_MAX, 2002, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2004, UINT16_MAX, 2004, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2006, UINT16_MAX, 2006, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2008, UINT16_MAX, 2008, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2010, UINT16_MAX, 2010, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2012, UINT16_MAX, 2012, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2014, UINT16_MAX, 2014, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2016, UINT16_MAX, 2016, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2018, UINT16_MAX, 2018, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2020, UINT16_MAX, 2020, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2022, UINT16_MAX, 2022, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2024, UINT16_MAX, 2024, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2026, UINT16_MAX, 2026, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2028, UINT16_MAX, 2028, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2030, UINT16_MAX, 2030, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2032, UINT16_MAX, 2032, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2034, UINT16_MAX, 2034, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2036, UINT16_MAX, 2036, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2038, UINT16_MAX, 2038, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2040, UINT16_MAX, 2040, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2042, UINT16_MAX, 2042, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2044, UINT16_MAX, 2044, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2046, UINT16_MAX, 2046, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2048, UINT16_MAX, 2048, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2050, UINT16_MAX, 2050, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2052, UINT16_MAX, 2052, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2054, UINT16_MAX, 2054, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2056, UINT16_MAX, 2056, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2058, UINT16_MAX, 2058, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2060, UINT16_MAX, 2060, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2062, UINT16_MAX, 2062, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2064, UINT16_MAX, 2064, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2066, UINT16_MAX, 2066, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2068, UINT16_MAX, 2068, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2070, UINT16_MAX, 2070, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2072, UINT16_MAX, 2072, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2074, UINT16_MAX, 2074, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2076, UINT16_MAX, 2076, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2078, UINT16_MAX, 2078, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2080, UINT16_MAX, 2080, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2083, UINT16_MAX, 2083, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2085, UINT16_MAX, 2085, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2087, UINT16_MAX, 2087, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2204, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2205, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2206, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2207, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2208, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2209, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2210, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2211, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2212, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2213, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2214, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2215, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2216, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2217, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2218, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2219, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2220, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2221, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2222, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2223, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2224, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2225, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2226, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2227, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2228, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2229, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2230, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2231, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2232, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2233, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2234, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2235, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2236, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2237, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2238, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2239, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2240, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2241, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2242, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2243, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2244, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2245, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2246, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2247, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 26, UINT16_MAX, 2248, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 180, UINT16_MAX, 2249, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 27, UINT16_MAX, 2250, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2251, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 29, UINT16_MAX, 2252, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 30, UINT16_MAX, 2253, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 746, UINT16_MAX, 2254, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 32, UINT16_MAX, 2255, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 33, UINT16_MAX, 2256, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 34, UINT16_MAX, 2257, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 35, UINT16_MAX, 2258, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 36, UINT16_MAX, 2259, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 37, UINT16_MAX, 2260, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 38, UINT16_MAX, 2261, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 39, UINT16_MAX, 2262, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2263, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 40, UINT16_MAX, 2264, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 936, UINT16_MAX, 2265, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 41, UINT16_MAX, 2266, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 43, UINT16_MAX, 2267, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 45, UINT16_MAX, 2268, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 46, UINT16_MAX, 2269, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 48, UINT16_MAX, 2270, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 0, UINT16_MAX, 2271, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2272, UINT16_MAX, 2273, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2274, UINT16_MAX, 2275, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2206, UINT16_MAX, 2276, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1, UINT16_MAX, 2277, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3, UINT16_MAX, 2278, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 4, UINT16_MAX, 2279, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 615, UINT16_MAX, 2280, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 616, UINT16_MAX, 2281, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2282, UINT16_MAX, 2283, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 6, UINT16_MAX, 2284, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2285, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 10, UINT16_MAX, 2286, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 12, UINT16_MAX, 2287, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 453, UINT16_MAX, 2288, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 14, UINT16_MAX, 2289, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 606, UINT16_MAX, 2290, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2226, UINT16_MAX, 2291, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2227, UINT16_MAX, 2292, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 15, UINT16_MAX, 2293, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 19, UINT16_MAX, 2294, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 20, UINT16_MAX, 2295, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2233, UINT16_MAX, 2296, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 628, UINT16_MAX, 2297, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 21, UINT16_MAX, 2298, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2241, UINT16_MAX, 2299, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1186, UINT16_MAX, 2300, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1187, UINT16_MAX, 2301, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1188, UINT16_MAX, 2302, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1203, UINT16_MAX, 2303, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1204, UINT16_MAX, 2304, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 8, UINT16_MAX, 2305, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 17, UINT16_MAX, 2306, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 20, UINT16_MAX, 2307, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 21, UINT16_MAX, 2308, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1186, UINT16_MAX, 2309, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1187, UINT16_MAX, 2310, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1199, UINT16_MAX, 2311, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1203, UINT16_MAX, 2312, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1204, UINT16_MAX, 2313, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2314, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2315, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2316, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2317, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2318, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2319, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2320, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2321, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2322, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2323, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2324, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2325, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2326, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1358, UINT16_MAX, 2327, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2328, UINT16_MAX, 2328, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2329, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2330, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2331, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2332, UINT16_MAX, 2332, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2333, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2334, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2335, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2336, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2337, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2338, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2339, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2340, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2341, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2342, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2343, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2344, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2345, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2346, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2347, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2348, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2349, UINT16_MAX, 2349, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2350, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2351, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2352, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2353, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2354, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2355, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2356, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2357, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2358, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2359, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2360, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2361, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2362, UINT16_MAX, 2363, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2, UINT16_MAX, 2364, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1014, UINT16_MAX, 2365, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 123, UINT16_MAX, 2366, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2282, UINT16_MAX, 2367, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5, UINT16_MAX, 2368, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1024, UINT16_MAX, 2369, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2370, UINT16_MAX, 2371, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2372, UINT16_MAX, 2373, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 623, UINT16_MAX, 2374, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 622, UINT16_MAX, 2375, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2376, UINT16_MAX, 2377, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2330, UINT16_MAX, 2378, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2379, UINT16_MAX, 2380, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1038, UINT16_MAX, 2381, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2340, UINT16_MAX, 2382, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1087, UINT16_MAX, 2383, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2384, UINT16_MAX, 2385, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1041, UINT16_MAX, 2386, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 629, UINT16_MAX, 2387, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1044, UINT16_MAX, 2388, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1045, UINT16_MAX, 2389, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 631, UINT16_MAX, 2390, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1049, UINT16_MAX, 2391, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2392, UINT16_MAX, 2393, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 645, UINT16_MAX, 2394, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 647, UINT16_MAX, 2395, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 997, UINT16_MAX, 2396, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 657, UINT16_MAX, 2397, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2232, UINT16_MAX, 2398, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 658, UINT16_MAX, 2399, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 998, UINT16_MAX, 2400, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 25, UINT16_MAX, 2401, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1073, UINT16_MAX, 2402, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1074, UINT16_MAX, 2403, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 663, UINT16_MAX, 2404, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1192, UINT16_MAX, 2405, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 214, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 218, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18790, 2408, UINT16_MAX, 2408, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18793, UINT16_MAX, 2411, UINT16_MAX, 2411, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18796, 2414, UINT16_MAX, 2414, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18799, UINT16_MAX, 2417, UINT16_MAX, 2417, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18802, 2420, UINT16_MAX, 2420, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18805, UINT16_MAX, 2423, UINT16_MAX, 2423, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18808, 2426, UINT16_MAX, 2426, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18811, UINT16_MAX, 2429, UINT16_MAX, 2429, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18814, 2432, UINT16_MAX, 2432, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18817, UINT16_MAX, 2435, UINT16_MAX, 2435, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18820, 2438, UINT16_MAX, 2438, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18823, UINT16_MAX, 2441, UINT16_MAX, 2441, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18826, 2444, UINT16_MAX, 2444, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18829, UINT16_MAX, 2447, UINT16_MAX, 2447, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18832, 2450, UINT16_MAX, 2450, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18835, UINT16_MAX, 2453, UINT16_MAX, 2453, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18838, 2456, UINT16_MAX, 2456, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18841, UINT16_MAX, 2459, UINT16_MAX, 2459, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18844, 2462, UINT16_MAX, 2462, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18847, UINT16_MAX, 2465, UINT16_MAX, 2465, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18850, 2468, UINT16_MAX, 2468, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18853, UINT16_MAX, 2471, UINT16_MAX, 2471, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18856, 2474, UINT16_MAX, 2474, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18859, UINT16_MAX, 2477, UINT16_MAX, 2477, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18862, 2480, UINT16_MAX, 2480, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18865, UINT16_MAX, 2483, UINT16_MAX, 2483, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18868, 2486, UINT16_MAX, 2486, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18871, UINT16_MAX, 2489, UINT16_MAX, 2489, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18874, 2492, UINT16_MAX, 2492, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18877, UINT16_MAX, 2495, UINT16_MAX, 2495, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18880, 2498, UINT16_MAX, 2498, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18883, UINT16_MAX, 2501, UINT16_MAX, 2501, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18886, 2504, UINT16_MAX, 2504, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18889, UINT16_MAX, 2507, UINT16_MAX, 2507, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18892, 2510, UINT16_MAX, 2510, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18895, UINT16_MAX, 2513, UINT16_MAX, 2513, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18898, 2516, UINT16_MAX, 2516, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18901, UINT16_MAX, 2519, UINT16_MAX, 2519, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18904, 2522, UINT16_MAX, 2522, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18907, UINT16_MAX, 2525, UINT16_MAX, 2525, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18910, 2528, UINT16_MAX, 2528, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18913, UINT16_MAX, 2531, UINT16_MAX, 2531, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18916, 2534, UINT16_MAX, 2534, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18919, UINT16_MAX, 2537, UINT16_MAX, 2537, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18922, 2540, UINT16_MAX, 2540, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18925, UINT16_MAX, 2543, UINT16_MAX, 2543, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18928, 2546, UINT16_MAX, 2546, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18931, UINT16_MAX, 2549, UINT16_MAX, 2549, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18934, 2552, UINT16_MAX, 2552, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18937, UINT16_MAX, 2555, UINT16_MAX, 2555, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18940, 2558, UINT16_MAX, 2558, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18943, UINT16_MAX, 2561, UINT16_MAX, 2561, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18946, 2564, UINT16_MAX, 2564, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18949, UINT16_MAX, 2567, UINT16_MAX, 2567, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18952, 2570, UINT16_MAX, 2570, UINT16_MAX, 2884, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18955, UINT16_MAX, 2573, UINT16_MAX, 2573, 2887, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18958, 2576, UINT16_MAX, 2576, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18961, UINT16_MAX, 2579, UINT16_MAX, 2579, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18964, 2582, UINT16_MAX, 2582, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18967, UINT16_MAX, 2585, UINT16_MAX, 2585, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18970, 2588, UINT16_MAX, 2588, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18973, UINT16_MAX, 2591, UINT16_MAX, 2591, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18976, 2594, UINT16_MAX, 2594, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18979, UINT16_MAX, 2597, UINT16_MAX, 2597, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18982, 2600, UINT16_MAX, 2600, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18985, UINT16_MAX, 2603, UINT16_MAX, 2603, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18988, 2606, UINT16_MAX, 2606, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18991, UINT16_MAX, 2609, UINT16_MAX, 2609, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 18994, 2612, UINT16_MAX, 2612, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 18997, UINT16_MAX, 2615, UINT16_MAX, 2615, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19000, 2618, UINT16_MAX, 2618, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19003, UINT16_MAX, 2621, UINT16_MAX, 2621, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19006, 2624, UINT16_MAX, 2624, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19009, UINT16_MAX, 2627, UINT16_MAX, 2627, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19012, 2630, UINT16_MAX, 2630, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19015, UINT16_MAX, 2633, UINT16_MAX, 2633, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19018, 2636, UINT16_MAX, 2636, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19021, UINT16_MAX, 2639, UINT16_MAX, 2639, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19024, 2642, UINT16_MAX, 2642, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19027, UINT16_MAX, 2645, UINT16_MAX, 2645, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19030, 2648, UINT16_MAX, 2648, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19033, UINT16_MAX, 2651, UINT16_MAX, 2651, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19036, 2654, UINT16_MAX, 2654, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19039, UINT16_MAX, 2657, UINT16_MAX, 2657, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19042, 2660, UINT16_MAX, 2660, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19045, UINT16_MAX, 2663, UINT16_MAX, 2663, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19048, 2666, UINT16_MAX, 2666, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19051, UINT16_MAX, 2669, UINT16_MAX, 2669, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19054, 2672, UINT16_MAX, 2672, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19057, UINT16_MAX, 2675, UINT16_MAX, 2675, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19060, 2678, UINT16_MAX, 2678, UINT16_MAX, 3006, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19063, UINT16_MAX, 2681, UINT16_MAX, 2681, 3009, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19066, 2684, UINT16_MAX, 2684, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19069, UINT16_MAX, 2687, UINT16_MAX, 2687, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19072, 2690, UINT16_MAX, 2690, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19075, UINT16_MAX, 2693, UINT16_MAX, 2693, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19078, 2696, UINT16_MAX, 2696, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19081, UINT16_MAX, 2699, UINT16_MAX, 2699, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19084, 2702, UINT16_MAX, 2702, UINT16_MAX, 3024, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19087, UINT16_MAX, 2705, UINT16_MAX, 2705, 3027, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19090, 2708, UINT16_MAX, 2708, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19093, UINT16_MAX, 2711, UINT16_MAX, 2711, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19096, 2714, UINT16_MAX, 2714, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19099, UINT16_MAX, 2717, UINT16_MAX, 2717, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19102, 2720, UINT16_MAX, 2720, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19105, UINT16_MAX, 2723, UINT16_MAX, 2723, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19108, 2726, UINT16_MAX, 2726, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19111, UINT16_MAX, 2729, UINT16_MAX, 2729, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19114, 2732, UINT16_MAX, 2732, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19117, UINT16_MAX, 2735, UINT16_MAX, 2735, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19120, 2738, UINT16_MAX, 2738, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19123, UINT16_MAX, 2741, UINT16_MAX, 2741, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19126, 2744, UINT16_MAX, 2744, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19129, UINT16_MAX, 2747, UINT16_MAX, 2747, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19132, 2750, UINT16_MAX, 2750, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19135, UINT16_MAX, 2753, UINT16_MAX, 2753, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19138, 2756, UINT16_MAX, 2756, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19141, UINT16_MAX, 2759, UINT16_MAX, 2759, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19144, 2762, UINT16_MAX, 2762, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19147, UINT16_MAX, 2765, UINT16_MAX, 2765, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19150, 2768, UINT16_MAX, 2768, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19153, UINT16_MAX, 2771, UINT16_MAX, 2771, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19156, 2774, UINT16_MAX, 2774, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19159, UINT16_MAX, 2777, UINT16_MAX, 2777, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19162, 2780, UINT16_MAX, 2780, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19165, UINT16_MAX, 2783, UINT16_MAX, 2783, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19168, 2786, UINT16_MAX, 2786, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19171, UINT16_MAX, 2789, UINT16_MAX, 2789, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19174, 2792, UINT16_MAX, 2792, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19177, UINT16_MAX, 2795, UINT16_MAX, 2795, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19180, 2798, UINT16_MAX, 2798, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19183, UINT16_MAX, 2801, UINT16_MAX, 2801, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19186, 2804, UINT16_MAX, 2804, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19189, UINT16_MAX, 2807, UINT16_MAX, 2807, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19192, 2810, UINT16_MAX, 2810, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19195, UINT16_MAX, 2813, UINT16_MAX, 2813, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19198, 2816, UINT16_MAX, 2816, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19201, UINT16_MAX, 2819, UINT16_MAX, 2819, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19204, 2822, UINT16_MAX, 2822, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19207, UINT16_MAX, 2825, UINT16_MAX, 2825, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19210, 2828, UINT16_MAX, 2828, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19213, UINT16_MAX, 2831, UINT16_MAX, 2831, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19216, 2834, UINT16_MAX, 2834, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19219, UINT16_MAX, 2837, UINT16_MAX, 2837, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19222, 2840, UINT16_MAX, 2840, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19225, UINT16_MAX, 2843, UINT16_MAX, 2843, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19228, 2846, UINT16_MAX, 2846, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19231, UINT16_MAX, 2849, UINT16_MAX, 2849, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19234, 2852, UINT16_MAX, 2852, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19237, UINT16_MAX, 2855, UINT16_MAX, 2855, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19240, 19240, 2858, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19243, 19243, 2861, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19246, 19246, 2864, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19249, 19249, 2867, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19252, 19252, 2870, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19255, 2696, 2699, UINT16_MAX, 2699, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2873, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2874, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 16543, UINT16_MAX, 2875, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2876, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19261, 2879, UINT16_MAX, 2879, UINT16_MAX, 3241, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19264, UINT16_MAX, 2882, UINT16_MAX, 2882, 3250, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19267, 2885, UINT16_MAX, 2885, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19270, UINT16_MAX, 2888, UINT16_MAX, 2888, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19273, 2891, UINT16_MAX, 2891, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19276, UINT16_MAX, 2894, UINT16_MAX, 2894, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19279, 2897, UINT16_MAX, 2897, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19282, UINT16_MAX, 2900, UINT16_MAX, 2900, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19285, 2903, UINT16_MAX, 2903, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19288, UINT16_MAX, 2906, UINT16_MAX, 2906, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19291, 2909, UINT16_MAX, 2909, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19294, UINT16_MAX, 2912, UINT16_MAX, 2912, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19297, 2915, UINT16_MAX, 2915, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19300, UINT16_MAX, 2918, UINT16_MAX, 2918, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19303, 2921, UINT16_MAX, 2921, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19306, UINT16_MAX, 2924, UINT16_MAX, 2924, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19309, 2927, UINT16_MAX, 2927, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19312, UINT16_MAX, 2930, UINT16_MAX, 2930, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19315, 2933, UINT16_MAX, 2933, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19318, UINT16_MAX, 2936, UINT16_MAX, 2936, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19321, 2939, UINT16_MAX, 2939, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19324, UINT16_MAX, 2942, UINT16_MAX, 2942, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19327, 2945, UINT16_MAX, 2945, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19330, UINT16_MAX, 2948, UINT16_MAX, 2948, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19333, 2951, UINT16_MAX, 2951, UINT16_MAX, 3455, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19336, UINT16_MAX, 2954, UINT16_MAX, 2954, 3458, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19339, 2957, UINT16_MAX, 2957, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19342, UINT16_MAX, 2960, UINT16_MAX, 2960, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19345, 2963, UINT16_MAX, 2963, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19348, UINT16_MAX, 2966, UINT16_MAX, 2966, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19351, 2969, UINT16_MAX, 2969, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19354, UINT16_MAX, 2972, UINT16_MAX, 2972, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19357, 2975, UINT16_MAX, 2975, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19360, UINT16_MAX, 2978, UINT16_MAX, 2978, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19363, 2981, UINT16_MAX, 2981, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19366, UINT16_MAX, 2984, UINT16_MAX, 2984, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19369, 2987, UINT16_MAX, 2987, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19372, UINT16_MAX, 2990, UINT16_MAX, 2990, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19375, 2993, UINT16_MAX, 2993, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19378, UINT16_MAX, 2996, UINT16_MAX, 2996, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19381, 2999, UINT16_MAX, 2999, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19384, UINT16_MAX, 3002, UINT16_MAX, 3002, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19387, 3005, UINT16_MAX, 3005, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19390, UINT16_MAX, 3008, UINT16_MAX, 3008, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19393, 3011, UINT16_MAX, 3011, UINT16_MAX, 3559, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19396, UINT16_MAX, 3014, UINT16_MAX, 3014, 3562, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19399, 3017, UINT16_MAX, 3017, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19402, UINT16_MAX, 3020, UINT16_MAX, 3020, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19405, 3023, UINT16_MAX, 3023, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19408, UINT16_MAX, 3026, UINT16_MAX, 3026, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19411, 3029, UINT16_MAX, 3029, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19414, UINT16_MAX, 3032, UINT16_MAX, 3032, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19417, 3035, UINT16_MAX, 3035, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19420, UINT16_MAX, 3038, UINT16_MAX, 3038, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19423, 3041, UINT16_MAX, 3041, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19426, UINT16_MAX, 3044, UINT16_MAX, 3044, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19429, 3047, UINT16_MAX, 3047, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19432, UINT16_MAX, 3050, UINT16_MAX, 3050, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19435, 3053, UINT16_MAX, 3053, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19438, UINT16_MAX, 3056, UINT16_MAX, 3056, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19441, 3059, UINT16_MAX, 3059, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19444, UINT16_MAX, 3062, UINT16_MAX, 3062, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19447, 3065, UINT16_MAX, 3065, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19450, UINT16_MAX, 3068, UINT16_MAX, 3068, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19453, 3071, UINT16_MAX, 3071, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19456, UINT16_MAX, 3074, UINT16_MAX, 3074, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19459, 3077, UINT16_MAX, 3077, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19462, UINT16_MAX, 3080, UINT16_MAX, 3080, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19465, 3083, UINT16_MAX, 3083, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19468, UINT16_MAX, 3086, UINT16_MAX, 3086, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19471, 3089, UINT16_MAX, 3089, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19474, UINT16_MAX, 3092, UINT16_MAX, 3092, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19477, 3095, UINT16_MAX, 3095, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19480, UINT16_MAX, 3098, UINT16_MAX, 3098, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19483, 3101, UINT16_MAX, 3101, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19486, UINT16_MAX, 3104, UINT16_MAX, 3104, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19489, 3107, UINT16_MAX, 3107, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19492, UINT16_MAX, 3110, UINT16_MAX, 3110, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19495, 3113, UINT16_MAX, 3113, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19498, UINT16_MAX, 3116, UINT16_MAX, 3116, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19501, 3119, UINT16_MAX, 3119, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19504, UINT16_MAX, 3122, UINT16_MAX, 3122, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19507, 3125, UINT16_MAX, 3125, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19510, UINT16_MAX, 3128, UINT16_MAX, 3128, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19513, 3131, UINT16_MAX, 3131, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19516, UINT16_MAX, 3134, UINT16_MAX, 3134, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19519, 3137, UINT16_MAX, 3137, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19522, UINT16_MAX, 3140, UINT16_MAX, 3140, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19525, 3143, UINT16_MAX, 3143, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19528, UINT16_MAX, 3146, UINT16_MAX, 3146, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3147, UINT16_MAX, 3147, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 3148, UINT16_MAX, 3148, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3149, UINT16_MAX, 3149, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 3150, UINT16_MAX, 3150, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3151, UINT16_MAX, 3151, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 3152, UINT16_MAX, 3152, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19537, UINT16_MAX, 3155, UINT16_MAX, 3155, 3761, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19540, UINT16_MAX, 3158, UINT16_MAX, 3158, 3814, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19543, UINT16_MAX, 3161, UINT16_MAX, 3161, 4793, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19546, UINT16_MAX, 3164, UINT16_MAX, 3164, 4796, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19549, UINT16_MAX, 3167, UINT16_MAX, 3167, 4799, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19552, UINT16_MAX, 3170, UINT16_MAX, 3170, 4802, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19555, UINT16_MAX, 3173, UINT16_MAX, 3173, 4805, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19558, UINT16_MAX, 3176, UINT16_MAX, 3176, 4808, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19561, 3179, UINT16_MAX, 3179, UINT16_MAX, 3867, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19564, 3182, UINT16_MAX, 3182, UINT16_MAX, 3920, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19567, 3185, UINT16_MAX, 3185, UINT16_MAX, 4811, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19570, 3188, UINT16_MAX, 3188, UINT16_MAX, 4814, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19573, 3191, UINT16_MAX, 3191, UINT16_MAX, 4817, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19576, 3194, UINT16_MAX, 3194, UINT16_MAX, 4820, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19579, 3197, UINT16_MAX, 3197, UINT16_MAX, 4823, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19582, 3200, UINT16_MAX, 3200, UINT16_MAX, 4826, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19585, UINT16_MAX, 3203, UINT16_MAX, 3203, 3973, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19588, UINT16_MAX, 3206, UINT16_MAX, 3206, 3977, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19591, UINT16_MAX, 3209, UINT16_MAX, 3209, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19594, UINT16_MAX, 3212, UINT16_MAX, 3212, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19597, UINT16_MAX, 3215, UINT16_MAX, 3215, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19600, UINT16_MAX, 3218, UINT16_MAX, 3218, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19603, 3221, UINT16_MAX, 3221, UINT16_MAX, 3981, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19606, 3224, UINT16_MAX, 3224, UINT16_MAX, 3985, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19609, 3227, UINT16_MAX, 3227, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19612, 3230, UINT16_MAX, 3230, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19615, 3233, UINT16_MAX, 3233, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19618, 3236, UINT16_MAX, 3236, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19621, UINT16_MAX, 3239, UINT16_MAX, 3239, 3989, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19624, UINT16_MAX, 3242, UINT16_MAX, 3242, 4042, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19627, UINT16_MAX, 3245, UINT16_MAX, 3245, 4829, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19630, UINT16_MAX, 3248, UINT16_MAX, 3248, 4832, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19633, UINT16_MAX, 3251, UINT16_MAX, 3251, 4835, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19636, UINT16_MAX, 3254, UINT16_MAX, 3254, 4838, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19639, UINT16_MAX, 3257, UINT16_MAX, 3257, 4841, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19642, UINT16_MAX, 3260, UINT16_MAX, 3260, 4844, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19645, 3263, UINT16_MAX, 3263, UINT16_MAX, 4095, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19648, 3266, UINT16_MAX, 3266, UINT16_MAX, 4148, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19651, 3269, UINT16_MAX, 3269, UINT16_MAX, 4847, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19654, 3272, UINT16_MAX, 3272, UINT16_MAX, 4850, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19657, 3275, UINT16_MAX, 3275, UINT16_MAX, 4853, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19660, 3278, UINT16_MAX, 3278, UINT16_MAX, 4856, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19663, 3281, UINT16_MAX, 3281, UINT16_MAX, 4859, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19666, 3284, UINT16_MAX, 3284, UINT16_MAX, 4862, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19669, UINT16_MAX, 3287, UINT16_MAX, 3287, 4201, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19672, UINT16_MAX, 3290, UINT16_MAX, 3290, 4253, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19675, UINT16_MAX, 3293, UINT16_MAX, 3293, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19678, UINT16_MAX, 3296, UINT16_MAX, 3296, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19681, UINT16_MAX, 3299, UINT16_MAX, 3299, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19684, UINT16_MAX, 3302, UINT16_MAX, 3302, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19687, UINT16_MAX, 3305, UINT16_MAX, 3305, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19690, UINT16_MAX, 3308, UINT16_MAX, 3308, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19693, 3311, UINT16_MAX, 3311, UINT16_MAX, 4305, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19696, 3314, UINT16_MAX, 3314, UINT16_MAX, 4357, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19699, 3317, UINT16_MAX, 3317, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19702, 3320, UINT16_MAX, 3320, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19705, 3323, UINT16_MAX, 3323, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19708, 3326, UINT16_MAX, 3326, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19711, 3329, UINT16_MAX, 3329, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19714, 3332, UINT16_MAX, 3332, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19717, UINT16_MAX, 3335, UINT16_MAX, 3335, 4409, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19720, UINT16_MAX, 3338, UINT16_MAX, 3338, 4413, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19723, UINT16_MAX, 3341, UINT16_MAX, 3341, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19726, UINT16_MAX, 3344, UINT16_MAX, 3344, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19729, UINT16_MAX, 3347, UINT16_MAX, 3347, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19732, UINT16_MAX, 3350, UINT16_MAX, 3350, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19735, 3353, UINT16_MAX, 3353, UINT16_MAX, 4417, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19738, 3356, UINT16_MAX, 3356, UINT16_MAX, 4421, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19741, 3359, UINT16_MAX, 3359, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19744, 3362, UINT16_MAX, 3362, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19747, 3365, UINT16_MAX, 3365, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19750, 3368, UINT16_MAX, 3368, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19753, 19753, 3371, UINT16_MAX, UINT16_MAX, 4425, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19756, UINT16_MAX, 3374, UINT16_MAX, 3374, 4477, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19759, 36145, 3380, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19765, UINT16_MAX, 3383, UINT16_MAX, 3383, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19768, 36154, 3389, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19774, UINT16_MAX, 3392, UINT16_MAX, 3392, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19777, 36163, 3398, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19783, UINT16_MAX, 3401, UINT16_MAX, 3401, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19786, 3404, UINT16_MAX, 3404, UINT16_MAX, 4529, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19789, 3407, UINT16_MAX, 3407, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19792, 3410, UINT16_MAX, 3410, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19795, 3413, UINT16_MAX, 3413, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19798, UINT16_MAX, 3416, UINT16_MAX, 3416, 4581, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19801, UINT16_MAX, 3419, UINT16_MAX, 3419, 4634, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19804, UINT16_MAX, 3422, UINT16_MAX, 3422, 4865, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19807, UINT16_MAX, 3425, UINT16_MAX, 3425, 4868, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19810, UINT16_MAX, 3428, UINT16_MAX, 3428, 4871, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19813, UINT16_MAX, 3431, UINT16_MAX, 3431, 4874, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19816, UINT16_MAX, 3434, UINT16_MAX, 3434, 4877, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19819, UINT16_MAX, 3437, UINT16_MAX, 3437, 4880, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19822, 3440, UINT16_MAX, 3440, UINT16_MAX, 4687, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19825, 3443, UINT16_MAX, 3443, UINT16_MAX, 4740, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19828, 3446, UINT16_MAX, 3446, UINT16_MAX, 4883, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19831, 3449, UINT16_MAX, 3449, UINT16_MAX, 4886, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19834, 3452, UINT16_MAX, 3452, UINT16_MAX, 4889, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19837, 3455, UINT16_MAX, 3455, UINT16_MAX, 4892, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19840, 3458, UINT16_MAX, 3458, UINT16_MAX, 4895, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 19843, 3461, UINT16_MAX, 3461, UINT16_MAX, 4898, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19846, UINT16_MAX, 3464, UINT16_MAX, 3464, 4901, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 1159, UINT16_MAX, 3465, UINT16_MAX, 3465, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19850, UINT16_MAX, 3468, UINT16_MAX, 3468, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 1163, UINT16_MAX, 3469, UINT16_MAX, 3469, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19854, UINT16_MAX, 3472, UINT16_MAX, 3472, 4910, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 1166, UINT16_MAX, 3473, UINT16_MAX, 3473, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19858, UINT16_MAX, 3476, UINT16_MAX, 3476, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 1169, UINT16_MAX, 3477, UINT16_MAX, 3477, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19862, UINT16_MAX, 3480, UINT16_MAX, 3480, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 1172, UINT16_MAX, 3481, UINT16_MAX, 3481, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19866, UINT16_MAX, 3484, UINT16_MAX, 3484, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 1175, UINT16_MAX, 3485, UINT16_MAX, 3485, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19870, UINT16_MAX, 3488, UINT16_MAX, 3488, 5030, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 1178, UINT16_MAX, 3489, UINT16_MAX, 3489, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19874, 19876, 3494, UINT16_MAX, 3494, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19879, 19881, 3499, UINT16_MAX, 3499, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19884, 19886, 3504, UINT16_MAX, 3504, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19889, 19891, 3509, UINT16_MAX, 3509, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19894, 19896, 3514, UINT16_MAX, 3514, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19899, 19901, 3519, UINT16_MAX, 3519, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19904, 19906, 3524, UINT16_MAX, 3524, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19909, 19911, 3529, UINT16_MAX, 3529, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19914, 19876, UINT16_MAX, 3532, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19917, 19881, UINT16_MAX, 3535, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19920, 19886, UINT16_MAX, 3538, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19923, 19891, UINT16_MAX, 3541, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19926, 19896, UINT16_MAX, 3544, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19929, 19901, UINT16_MAX, 3547, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19932, 19906, UINT16_MAX, 3550, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19935, 19911, UINT16_MAX, 3553, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19938, 19940, 3558, UINT16_MAX, 3558, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19943, 19945, 3563, UINT16_MAX, 3563, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19948, 19950, 3568, UINT16_MAX, 3568, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19953, 19955, 3573, UINT16_MAX, 3573, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19958, 19960, 3578, UINT16_MAX, 3578, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19963, 19965, 3583, UINT16_MAX, 3583, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19968, 19970, 3588, UINT16_MAX, 3588, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 19973, 19975, 3593, UINT16_MAX, 3593, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19978, 19940, UINT16_MAX, 3596, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19981, 19945, UINT16_MAX, 3599, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19984, 19950, UINT16_MAX, 3602, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19987, 19955, UINT16_MAX, 3605, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19990, 19960, UINT16_MAX, 3608, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19993, 19965, UINT16_MAX, 3611, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19996, 19970, UINT16_MAX, 3614, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 19999, 19975, UINT16_MAX, 3617, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20002, 20004, 3622, UINT16_MAX, 3622, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20007, 20009, 3627, UINT16_MAX, 3627, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20012, 20014, 3632, UINT16_MAX, 3632, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20017, 20019, 3637, UINT16_MAX, 3637, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20022, 20024, 3642, UINT16_MAX, 3642, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20027, 20029, 3647, UINT16_MAX, 3647, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20032, 20034, 3652, UINT16_MAX, 3652, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20037, 20039, 3657, UINT16_MAX, 3657, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 20042, 20004, UINT16_MAX, 3660, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 20045, 20009, UINT16_MAX, 3663, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 20048, 20014, UINT16_MAX, 3666, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 20051, 20019, UINT16_MAX, 3669, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 20054, 20024, UINT16_MAX, 3672, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 20057, 20029, UINT16_MAX, 3675, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 20060, 20034, UINT16_MAX, 3678, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 20063, 20039, UINT16_MAX, 3681, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20066, UINT16_MAX, 3684, UINT16_MAX, 3684, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20069, UINT16_MAX, 3687, UINT16_MAX, 3687, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20072, 20074, 3692, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20077, 20079, 3697, UINT16_MAX, 3697, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20082, 20084, 3702, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20087, 20087, 3705, UINT16_MAX, UINT16_MAX, 4907, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20090, 36476, 3711, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 20096, 3714, UINT16_MAX, 3714, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 20099, 3717, UINT16_MAX, 3717, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 20102, 3720, UINT16_MAX, 3720, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 1215, 3721, UINT16_MAX, 3721, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 20106, 20079, UINT16_MAX, 3724, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20109, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 1138, 1138, 1139, UINT16_MAX, 1139, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20109, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 4919, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20111, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20113, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20115, 20117, 3735, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20120, 20122, 3740, UINT16_MAX, 3740, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20125, 20127, 3745, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20130, 20130, 3748, UINT16_MAX, UINT16_MAX, 4916, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20133, 36519, 3754, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 20139, 3757, UINT16_MAX, 3757, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 1218, 3758, UINT16_MAX, 3758, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 20143, 3761, UINT16_MAX, 3761, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 1221, 3762, UINT16_MAX, 3762, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 20147, 20122, UINT16_MAX, 3765, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20150, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20152, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20154, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20156, UINT16_MAX, 3774, UINT16_MAX, 3774, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20159, UINT16_MAX, 3777, UINT16_MAX, 3777, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20162, 36548, 3783, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 1184, 33949, 3784, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20169, 20169, 3787, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20172, 36558, 3793, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 20178, 3796, UINT16_MAX, 3796, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 20181, 3799, UINT16_MAX, 3799, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 20184, 3802, UINT16_MAX, 3802, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 1224, 3803, UINT16_MAX, 3803, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20188, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20190, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20192, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20194, UINT16_MAX, 3812, UINT16_MAX, 3812, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20197, UINT16_MAX, 3815, UINT16_MAX, 3815, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20200, 36586, 3821, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 1230, 33995, 3822, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20207, 20207, 3825, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20210, UINT16_MAX, 3828, UINT16_MAX, 3828, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20213, 20213, 3831, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20216, 36602, 3837, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 20222, 3840, UINT16_MAX, 3840, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 20225, 3843, UINT16_MAX, 3843, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 20228, 3846, UINT16_MAX, 3846, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 1264, 3847, UINT16_MAX, 3847, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 20232, 3850, UINT16_MAX, 3850, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20235, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 3853, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 3854, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20239, 20241, 3859, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20244, 20246, 3864, UINT16_MAX, 3864, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20249, 20251, 3869, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20254, 20254, 3872, UINT16_MAX, UINT16_MAX, 5036, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 20257, 36643, 3878, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 20263, 3881, UINT16_MAX, 3881, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 1261, 3882, UINT16_MAX, 3882, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 20267, 3885, UINT16_MAX, 3885, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 1267, 3886, UINT16_MAX, 3886, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 20271, 20246, UINT16_MAX, 3889, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 3890, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20275, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 4971, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ZS, 0, UTF8PROC_BIDI_CLASS_WS, 0, 3893, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ZS, 0, UTF8PROC_BIDI_CLASS_WS, 0, 3894, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ZS, 0, UTF8PROC_BIDI_CLASS_WS, UTF8PROC_DECOMP_TYPE_COMPAT, 52, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ZS, 0, UTF8PROC_BIDI_CLASS_WS, UTF8PROC_DECOMP_TYPE_NOBREAK, 52, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_BN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_BN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, false, 0, 0, UTF8PROC_BOUNDCLASS_ZWJ, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NOBREAK, 3895, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20280, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PI, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PF, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3898, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20283, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 36669, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ZL, 0, UTF8PROC_BIDI_CLASS_WS, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ZP, 0, UTF8PROC_BIDI_CLASS_B, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_LRE, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_RLE, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_PDF, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_LRO, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_RLO, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_COMPAT, 20288, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_COMPAT, 36674, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20293, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 36679, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20298, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20300, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_CS, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20302, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20304, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20306, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 53076, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_LRI, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_RLI, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_FSI, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_PDI, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 3929, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 8, UINT16_MAX, 3930, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 3931, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 3932, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 3933, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 3934, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 3935, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 3936, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_SUPER, 3937, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_SUPER, 3938, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 3939, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 3940, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 3941, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 13, UINT16_MAX, 3942, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 3929, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 66, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 58, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 59, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 3931, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 3932, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 3933, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 3934, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 3935, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 3936, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_SUB, 3937, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_SUB, 3938, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUB, 3939, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUB, 3940, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUB, 3941, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 0, UINT16_MAX, 3943, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 4, UINT16_MAX, 3944, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 14, UINT16_MAX, 3945, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 23, UINT16_MAX, 3946, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 615, UINT16_MAX, 3947, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 7, UINT16_MAX, 3948, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 10, UINT16_MAX, 3949, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 11, UINT16_MAX, 3950, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 12, UINT16_MAX, 3951, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 13, UINT16_MAX, 3952, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 15, UINT16_MAX, 3953, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 18, UINT16_MAX, 3954, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 19, UINT16_MAX, 3955, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_COMPAT, 20340, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 36726, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 36729, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 28, UINT16_MAX, UINT16_MAX, 3964, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20349, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 36735, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 36738, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1020, UINT16_MAX, UINT16_MAX, 3973, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20358, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 6, UINT16_MAX, 3976, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 33, UINT16_MAX, UINT16_MAX, 3977, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 33, UINT16_MAX, UINT16_MAX, 3978, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 33, UINT16_MAX, UINT16_MAX, 3979, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7, UINT16_MAX, 3980, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 357, UINT16_MAX, 3981, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 34, UINT16_MAX, UINT16_MAX, 3982, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 34, UINT16_MAX, UINT16_MAX, 3983, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 37, UINT16_MAX, UINT16_MAX, 3984, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 11, UINT16_MAX, 3985, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 39, UINT16_MAX, UINT16_MAX, 3986, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20371, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 41, UINT16_MAX, UINT16_MAX, 3989, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 42, UINT16_MAX, UINT16_MAX, 3990, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 43, UINT16_MAX, UINT16_MAX, 3991, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 43, UINT16_MAX, UINT16_MAX, 3992, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 43, UINT16_MAX, UINT16_MAX, 3993, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 20378, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 36764, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 20383, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 51, UINT16_MAX, UINT16_MAX, 4001, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 1252, 1206, UINT16_MAX, 1206, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 51, UINT16_MAX, UINT16_MAX, 4002, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 36, 10, UINT16_MAX, 10, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 179, 94, UINT16_MAX, 94, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 27, UINT16_MAX, UINT16_MAX, 4003, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 28, UINT16_MAX, UINT16_MAX, 4004, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 4, UINT16_MAX, 4005, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 30, UINT16_MAX, UINT16_MAX, 4006, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 31, UINT16_MAX, UINT16_MAX, 4007, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4008, UINT16_MAX, 4008, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 38, UINT16_MAX, UINT16_MAX, 4009, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 14, UINT16_MAX, 4010, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 4011, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 4012, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 4013, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 4014, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, 4015, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 36784, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1198, UINT16_MAX, 4019, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1187, UINT16_MAX, 4020, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1233, UINT16_MAX, UINT16_MAX, 4021, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1244, UINT16_MAX, UINT16_MAX, 4022, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FONT, 4023, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 29, UINT16_MAX, UINT16_MAX, 4024, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3, UINT16_MAX, 4025, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 4, UINT16_MAX, 4026, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, 4027, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 9, UINT16_MAX, 4028, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4029, UINT16_MAX, 4029, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 36798, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 36801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 53188, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 36809, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 36812, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 36815, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 36818, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 36821, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 36824, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 36827, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 36830, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 36833, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 36836, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 36839, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 36842, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 20461, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 34, 4079, UINT16_MAX, 4079, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20464, 4082, UINT16_MAX, 4082, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 36851, 4086, UINT16_MAX, 4086, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20471, 4089, UINT16_MAX, 4089, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 47, 4090, UINT16_MAX, 4090, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20475, 4093, UINT16_MAX, 4093, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 36862, 4097, UINT16_MAX, 4097, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 53250, 4103, UINT16_MAX, 4103, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20488, 4106, UINT16_MAX, 4106, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 49, 4107, UINT16_MAX, 4107, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20492, 4110, UINT16_MAX, 4110, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 36879, 4114, UINT16_MAX, 4114, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37, 4115, UINT16_MAX, 4115, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28, 4116, UINT16_MAX, 4116, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 29, 4117, UINT16_MAX, 4117, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38, 4118, UINT16_MAX, 4118, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8, UINT16_MAX, 4119, UINT16_MAX, 4119, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20504, UINT16_MAX, 4122, UINT16_MAX, 4122, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 36891, UINT16_MAX, 4126, UINT16_MAX, 4126, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20511, UINT16_MAX, 4129, UINT16_MAX, 4129, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21, UINT16_MAX, 4130, UINT16_MAX, 4130, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20515, UINT16_MAX, 4133, UINT16_MAX, 4133, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 36902, UINT16_MAX, 4137, UINT16_MAX, 4137, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 53290, UINT16_MAX, 4143, UINT16_MAX, 4143, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20528, UINT16_MAX, 4146, UINT16_MAX, 4146, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23, UINT16_MAX, 4147, UINT16_MAX, 4147, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20532, UINT16_MAX, 4150, UINT16_MAX, 4150, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 36919, UINT16_MAX, 4154, UINT16_MAX, 4154, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 11, UINT16_MAX, 4155, UINT16_MAX, 4155, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 2, UINT16_MAX, 4156, UINT16_MAX, 4156, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3, UINT16_MAX, 4157, UINT16_MAX, 4157, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12, UINT16_MAX, 4158, UINT16_MAX, 4158, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4159, UINT16_MAX, 4159, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4160, UINT16_MAX, 4160, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 36929, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5039, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5042, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5045, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20548, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20550, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20552, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20554, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20556, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20558, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5048, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5054, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5051, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5057, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20560, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5060, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20562, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5063, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20564, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5066, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20566, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5069, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20568, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20570, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 36956, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20575, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 36961, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5072, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20580, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5075, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20582, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5078, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20584, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5081, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20586, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5090, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20588, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5087, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20590, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5099, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5102, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20592, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20594, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20596, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20598, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5105, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5108, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20602, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20604, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5111, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5114, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20606, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20608, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5117, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5120, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5147, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5150, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20610, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20612, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5123, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5126, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20614, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20616, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5129, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5132, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20618, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20620, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5153, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5156, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5135, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5138, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5141, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5144, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20622, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20624, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20626, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20628, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5159, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5162, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5165, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5168, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20630, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20632, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20634, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20636, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20638, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20640, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20642, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20644, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, 0, 4262, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, 0, 4263, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 66, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 58, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 59, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 3931, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 3932, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 3933, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 3934, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 3935, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 3936, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 20648, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 20650, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 20652, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 20654, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 20656, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 20658, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 20660, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 20662, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 20664, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 20666, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 20668, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 37054, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 37057, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 37060, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 37063, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 37066, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 37069, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 37072, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 37075, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 37078, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 53465, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 53470, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 53475, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 53480, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 53485, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 53490, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 53495, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 53500, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 53505, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 53510, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 53515, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 20752, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 20754, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 20756, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 20758, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 20760, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 20762, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 20764, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 20766, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 20768, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 37154, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 37157, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 37160, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 37163, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 37166, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 37169, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 37172, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 37175, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 37178, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 37181, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 37184, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37187, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37190, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37193, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37196, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37199, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37202, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37205, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37208, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37211, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37214, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37217, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37220, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37223, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37226, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37229, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37232, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37235, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37238, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37241, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37244, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37247, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37250, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37253, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37256, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37259, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 37262, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 26, 4497, UINT16_MAX, 4497, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 27, 4498, UINT16_MAX, 4498, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 28, 4499, UINT16_MAX, 4499, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 29, 4500, UINT16_MAX, 4500, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 30, 4501, UINT16_MAX, 4501, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 31, 4502, UINT16_MAX, 4502, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 32, 4503, UINT16_MAX, 4503, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 33, 4504, UINT16_MAX, 4504, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 34, 4505, UINT16_MAX, 4505, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 35, 4506, UINT16_MAX, 4506, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 36, 4507, UINT16_MAX, 4507, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 37, 4508, UINT16_MAX, 4508, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 38, 4509, UINT16_MAX, 4509, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 39, 4510, UINT16_MAX, 4510, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 40, 4511, UINT16_MAX, 4511, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 41, 4512, UINT16_MAX, 4512, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 42, 4513, UINT16_MAX, 4513, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 43, 4514, UINT16_MAX, 4514, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 44, 4515, UINT16_MAX, 4515, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 45, 4516, UINT16_MAX, 4516, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 46, 4517, UINT16_MAX, 4517, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 47, 4518, UINT16_MAX, 4518, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 48, 4519, UINT16_MAX, 4519, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 49, 4520, UINT16_MAX, 4520, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 50, 4521, UINT16_MAX, 4521, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 51, 4522, UINT16_MAX, 4522, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 0, UINT16_MAX, 4523, UINT16_MAX, 4523, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1, UINT16_MAX, 4524, UINT16_MAX, 4524, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 2, UINT16_MAX, 4525, UINT16_MAX, 4525, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3, UINT16_MAX, 4526, UINT16_MAX, 4526, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4, UINT16_MAX, 4527, UINT16_MAX, 4527, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5, UINT16_MAX, 4528, UINT16_MAX, 4528, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 6, UINT16_MAX, 4529, UINT16_MAX, 4529, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 7, UINT16_MAX, 4530, UINT16_MAX, 4530, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 8, UINT16_MAX, 4531, UINT16_MAX, 4531, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 9, UINT16_MAX, 4532, UINT16_MAX, 4532, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 10, UINT16_MAX, 4533, UINT16_MAX, 4533, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 11, UINT16_MAX, 4534, UINT16_MAX, 4534, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12, UINT16_MAX, 4535, UINT16_MAX, 4535, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 13, UINT16_MAX, 4536, UINT16_MAX, 4536, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 14, UINT16_MAX, 4537, UINT16_MAX, 4537, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 15, UINT16_MAX, 4538, UINT16_MAX, 4538, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 16, UINT16_MAX, 4539, UINT16_MAX, 4539, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 17, UINT16_MAX, 4540, UINT16_MAX, 4540, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 18, UINT16_MAX, 4541, UINT16_MAX, 4541, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 19, UINT16_MAX, 4542, UINT16_MAX, 4542, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 20, UINT16_MAX, 4543, UINT16_MAX, 4543, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21, UINT16_MAX, 4544, UINT16_MAX, 4544, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 22, UINT16_MAX, 4545, UINT16_MAX, 4545, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 23, UINT16_MAX, 4546, UINT16_MAX, 4546, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 24, UINT16_MAX, 4547, UINT16_MAX, 4547, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 25, UINT16_MAX, 4548, UINT16_MAX, 4548, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 3929, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 53701, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 37322, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 20941, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 37327, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 20946, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5171, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4564, UINT16_MAX, 4564, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4565, UINT16_MAX, 4565, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4566, UINT16_MAX, 4566, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4567, UINT16_MAX, 4567, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4568, UINT16_MAX, 4568, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4569, UINT16_MAX, 4569, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4570, UINT16_MAX, 4570, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4571, UINT16_MAX, 4571, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4572, UINT16_MAX, 4572, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4573, UINT16_MAX, 4573, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4574, UINT16_MAX, 4574, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4575, UINT16_MAX, 4575, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4576, UINT16_MAX, 4576, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4577, UINT16_MAX, 4577, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4578, UINT16_MAX, 4578, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4579, UINT16_MAX, 4579, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4580, UINT16_MAX, 4580, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4581, UINT16_MAX, 4581, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4582, UINT16_MAX, 4582, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4583, UINT16_MAX, 4583, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4584, UINT16_MAX, 4584, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4585, UINT16_MAX, 4585, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4586, UINT16_MAX, 4586, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4587, UINT16_MAX, 4587, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4588, UINT16_MAX, 4588, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4589, UINT16_MAX, 4589, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4590, UINT16_MAX, 4590, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4591, UINT16_MAX, 4591, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4592, UINT16_MAX, 4592, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4593, UINT16_MAX, 4593, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4594, UINT16_MAX, 4594, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4595, UINT16_MAX, 4595, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4596, UINT16_MAX, 4596, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4597, UINT16_MAX, 4597, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4598, UINT16_MAX, 4598, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4599, UINT16_MAX, 4599, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4600, UINT16_MAX, 4600, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4601, UINT16_MAX, 4601, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4602, UINT16_MAX, 4602, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4603, UINT16_MAX, 4603, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4604, UINT16_MAX, 4604, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4605, UINT16_MAX, 4605, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4606, UINT16_MAX, 4606, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4607, UINT16_MAX, 4607, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4608, UINT16_MAX, 4608, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4609, UINT16_MAX, 4609, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4610, UINT16_MAX, 4610, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4611, UINT16_MAX, 4611, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4612, UINT16_MAX, 4612, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4613, UINT16_MAX, 4613, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4614, UINT16_MAX, 4614, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4615, UINT16_MAX, 4615, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4616, UINT16_MAX, 4616, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4617, UINT16_MAX, 4617, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4618, UINT16_MAX, 4618, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4619, UINT16_MAX, 4619, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4620, UINT16_MAX, 4620, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4621, UINT16_MAX, 4621, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4622, UINT16_MAX, 4622, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4623, UINT16_MAX, 4623, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4624, UINT16_MAX, 4624, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4625, UINT16_MAX, 4625, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4626, UINT16_MAX, 4626, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4627, UINT16_MAX, 4627, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4628, UINT16_MAX, 4628, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4629, UINT16_MAX, 4629, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4630, UINT16_MAX, 4630, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4631, UINT16_MAX, 4631, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4632, UINT16_MAX, 4632, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4633, UINT16_MAX, 4633, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4634, UINT16_MAX, 4634, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4635, UINT16_MAX, 4635, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4636, UINT16_MAX, 4636, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4637, UINT16_MAX, 4637, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4638, UINT16_MAX, 4638, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4639, UINT16_MAX, 4639, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4640, UINT16_MAX, 4640, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4641, UINT16_MAX, 4641, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4642, UINT16_MAX, 4642, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4643, UINT16_MAX, 4643, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4644, UINT16_MAX, 4644, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4645, UINT16_MAX, 4645, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4646, UINT16_MAX, 4646, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4647, UINT16_MAX, 4647, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4648, UINT16_MAX, 4648, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4649, UINT16_MAX, 4649, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4650, UINT16_MAX, 4650, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4651, UINT16_MAX, 4651, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4652, UINT16_MAX, 4652, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4653, UINT16_MAX, 4653, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4654, UINT16_MAX, 4654, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4655, UINT16_MAX, 4655, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4656, UINT16_MAX, 4656, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4657, UINT16_MAX, 4657, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4658, UINT16_MAX, 4658, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4659, UINT16_MAX, 4659, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4660, UINT16_MAX, 4660, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4661, UINT16_MAX, 4661, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4662, UINT16_MAX, 4662, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4663, UINT16_MAX, 4663, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4664, UINT16_MAX, 4664, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4665, UINT16_MAX, 4665, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4666, UINT16_MAX, 4666, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4667, UINT16_MAX, 4667, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4668, UINT16_MAX, 4668, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4669, UINT16_MAX, 4669, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4670, UINT16_MAX, 4670, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4671, UINT16_MAX, 4671, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4672, UINT16_MAX, 4672, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2274, UINT16_MAX, 2274, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2384, UINT16_MAX, 2384, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2272, UINT16_MAX, 2272, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2362, UINT16_MAX, 2362, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4673, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4674, UINT16_MAX, 4674, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4675, UINT16_MAX, 4675, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4676, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4677, UINT16_MAX, 4677, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4678, UINT16_MAX, 4678, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4679, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4680, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4681, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4682, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4683, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 9, UINT16_MAX, 4684, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 47, UINT16_MAX, 4685, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4686, UINT16_MAX, 4686, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4687, UINT16_MAX, 4687, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4688, UINT16_MAX, 4688, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4689, UINT16_MAX, 4689, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4690, UINT16_MAX, 4690, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4691, UINT16_MAX, 4691, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4692, UINT16_MAX, 4692, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4693, UINT16_MAX, 4693, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4694, UINT16_MAX, 4694, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4695, UINT16_MAX, 4695, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4696, UINT16_MAX, 4696, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4697, UINT16_MAX, 4697, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4698, UINT16_MAX, 4698, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4699, UINT16_MAX, 4699, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4700, UINT16_MAX, 4700, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4701, UINT16_MAX, 4701, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4702, UINT16_MAX, 4702, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4703, UINT16_MAX, 4703, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4704, UINT16_MAX, 4704, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4705, UINT16_MAX, 4705, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4706, UINT16_MAX, 4706, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4707, UINT16_MAX, 4707, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4708, UINT16_MAX, 4708, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4709, UINT16_MAX, 4709, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4710, UINT16_MAX, 4710, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4711, UINT16_MAX, 4711, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4712, UINT16_MAX, 4712, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4713, UINT16_MAX, 4713, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4714, UINT16_MAX, 4714, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4715, UINT16_MAX, 4715, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4716, UINT16_MAX, 4716, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4717, UINT16_MAX, 4717, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4718, UINT16_MAX, 4718, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4719, UINT16_MAX, 4719, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4720, UINT16_MAX, 4720, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4721, UINT16_MAX, 4721, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4722, UINT16_MAX, 4722, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4723, UINT16_MAX, 4723, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4724, UINT16_MAX, 4724, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4725, UINT16_MAX, 4725, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4726, UINT16_MAX, 4726, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4727, UINT16_MAX, 4727, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4728, UINT16_MAX, 4728, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4729, UINT16_MAX, 4729, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4730, UINT16_MAX, 4730, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4731, UINT16_MAX, 4731, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4732, UINT16_MAX, 4732, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4733, UINT16_MAX, 4733, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4734, UINT16_MAX, 4734, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4735, UINT16_MAX, 4735, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4736, UINT16_MAX, 4736, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4737, UINT16_MAX, 4737, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4738, UINT16_MAX, 4738, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4739, UINT16_MAX, 4739, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4740, UINT16_MAX, 4740, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4741, UINT16_MAX, 4741, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4742, UINT16_MAX, 4742, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4743, UINT16_MAX, 4743, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4744, UINT16_MAX, 4744, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4745, UINT16_MAX, 4745, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4746, UINT16_MAX, 4746, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4747, UINT16_MAX, 4747, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4748, UINT16_MAX, 4748, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4749, UINT16_MAX, 4749, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4750, UINT16_MAX, 4750, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4751, UINT16_MAX, 4751, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4752, UINT16_MAX, 4752, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4753, UINT16_MAX, 4753, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4754, UINT16_MAX, 4754, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4755, UINT16_MAX, 4755, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4756, UINT16_MAX, 4756, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4757, UINT16_MAX, 4757, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4758, UINT16_MAX, 4758, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4759, UINT16_MAX, 4759, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4760, UINT16_MAX, 4760, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4761, UINT16_MAX, 4761, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4762, UINT16_MAX, 4762, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4763, UINT16_MAX, 4763, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4764, UINT16_MAX, 4764, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4765, UINT16_MAX, 4765, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4766, UINT16_MAX, 4766, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4767, UINT16_MAX, 4767, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4768, UINT16_MAX, 4768, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4769, UINT16_MAX, 4769, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4770, UINT16_MAX, 4770, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4771, UINT16_MAX, 4771, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4772, UINT16_MAX, 4772, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4773, UINT16_MAX, 4773, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4774, UINT16_MAX, 4774, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4775, UINT16_MAX, 4775, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4776, UINT16_MAX, 4776, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4777, UINT16_MAX, 4777, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4778, UINT16_MAX, 4778, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4779, UINT16_MAX, 4779, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4780, UINT16_MAX, 4780, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4781, UINT16_MAX, 4781, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4782, UINT16_MAX, 4782, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4783, UINT16_MAX, 4783, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4784, UINT16_MAX, 4784, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4785, UINT16_MAX, 4785, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4786, UINT16_MAX, 4786, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4787, UINT16_MAX, 4787, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4788, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4789, UINT16_MAX, 4789, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4790, UINT16_MAX, 4790, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4791, UINT16_MAX, 4791, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4792, UINT16_MAX, 4792, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4793, UINT16_MAX, 4793, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4794, UINT16_MAX, 4794, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4795, UINT16_MAX, 4795, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4796, UINT16_MAX, 4796, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4797, UINT16_MAX, 4797, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4798, UINT16_MAX, 4798, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4799, UINT16_MAX, 4799, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4800, UINT16_MAX, 4800, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4801, UINT16_MAX, 4801, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4802, UINT16_MAX, 4802, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4803, UINT16_MAX, 4803, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4804, UINT16_MAX, 4804, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4805, UINT16_MAX, 4805, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4806, UINT16_MAX, 4806, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4807, UINT16_MAX, 4807, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4808, UINT16_MAX, 4808, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4809, UINT16_MAX, 4809, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4810, UINT16_MAX, 4810, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4811, UINT16_MAX, 4811, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4812, UINT16_MAX, 4812, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4813, UINT16_MAX, 4813, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4814, UINT16_MAX, 4814, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4815, UINT16_MAX, 4815, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4816, UINT16_MAX, 4816, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4817, UINT16_MAX, 4817, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4818, UINT16_MAX, 4818, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4819, UINT16_MAX, 4819, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4820, UINT16_MAX, 4820, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4821, UINT16_MAX, 4821, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4822, UINT16_MAX, 4822, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4823, UINT16_MAX, 4823, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4824, UINT16_MAX, 4824, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4825, UINT16_MAX, 4825, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4826, UINT16_MAX, 4826, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4827, UINT16_MAX, 4827, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4828, UINT16_MAX, 4828, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4829, UINT16_MAX, 4829, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4830, UINT16_MAX, 4830, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4831, UINT16_MAX, 4831, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4832, UINT16_MAX, 4832, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4833, UINT16_MAX, 4833, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 4834, UINT16_MAX, 4834, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 4835, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4836, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4837, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4838, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4839, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4840, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4841, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4842, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4843, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4844, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4845, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4846, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4847, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4848, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4849, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4850, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4851, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4852, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4853, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4854, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4855, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4856, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4857, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4858, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4859, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4860, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4861, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4862, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4863, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4864, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4865, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4866, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4867, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4868, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4869, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4870, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4871, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4872, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4873, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4874, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4875, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4876, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4877, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4878, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4879, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4880, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4881, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4882, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4883, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4884, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4885, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4886, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4887, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4888, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4889, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4890, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4891, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4892, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4893, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4894, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4895, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4896, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4897, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4898, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4899, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4900, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4901, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4902, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4903, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4904, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4905, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4906, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4907, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4908, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4909, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4910, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4911, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4912, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4913, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4914, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4915, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4916, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4917, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4918, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4919, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4920, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4921, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4922, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4923, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4924, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4925, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4926, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4927, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4928, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4929, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4930, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4931, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4932, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4933, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4934, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4935, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4936, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4937, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4938, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4939, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4940, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4941, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4942, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4943, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4944, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4945, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4946, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4947, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4948, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4949, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4950, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4951, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4952, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4953, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4954, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4955, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4956, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4957, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4958, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4959, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4960, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4961, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4962, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4963, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4964, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4965, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4966, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4967, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4968, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4969, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4970, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4971, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4972, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4973, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4974, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4975, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4976, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4977, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4978, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4979, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4980, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4981, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4982, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4983, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4984, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4985, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4986, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4987, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4988, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4989, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4990, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4991, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4992, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4993, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4994, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4995, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4996, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4997, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4998, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 4999, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5000, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5001, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5002, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5003, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5004, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5005, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5006, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5007, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5008, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5009, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5010, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5011, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5012, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5013, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5014, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5015, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5016, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5017, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5018, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5019, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5020, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5021, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5022, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5023, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5024, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5025, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5026, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5027, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5028, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5029, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5030, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5031, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5032, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5033, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5034, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5035, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5036, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5037, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5038, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5039, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5040, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5041, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5042, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5043, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5044, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5045, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5046, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5047, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5048, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5049, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5050, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5051, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ZS, 0, UTF8PROC_BIDI_CLASS_WS, UTF8PROC_DECOMP_TYPE_WIDE, 52, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 224, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 5052, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 4861, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5053, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5054, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5239, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5174, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21439, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5177, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21441, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5180, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21443, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5183, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21445, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5186, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21447, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5189, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21449, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5192, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21451, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5195, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21453, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5198, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21455, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5201, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21457, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5204, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21459, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5207, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21461, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5210, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21463, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5213, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21465, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5216, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21467, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5219, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21469, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21471, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5223, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21473, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21475, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5227, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21477, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21479, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5231, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21481, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21483, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5235, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21485, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21487, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21489, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 8, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32820, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MN, 8, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32821, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 21491, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 21493, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5242, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, 21495, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_VERTICAL, 21497, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5310, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5245, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21499, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5248, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21501, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5251, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21503, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5254, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21505, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5257, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21507, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5260, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21509, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5263, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21511, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5266, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21513, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5269, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21515, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5272, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21517, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5275, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21519, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5278, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21521, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5281, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21523, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5284, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21525, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5287, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21527, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5290, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21529, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21531, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5294, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21533, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21535, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5298, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21537, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21539, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5302, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21541, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21543, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5306, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21545, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21547, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5313, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5316, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5319, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5322, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21549, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21551, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21553, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21555, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 21557, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5325, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, 21559, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_VERTICAL, 21561, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5179, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5180, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5181, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5182, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5183, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5184, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5185, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5186, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5187, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5188, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5190, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5191, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5192, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5193, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5194, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5195, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5196, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5197, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5198, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5199, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5200, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5201, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5202, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5203, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5204, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5205, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5206, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5207, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5208, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5209, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5210, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5211, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5212, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5213, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5214, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5215, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5216, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5217, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5218, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5219, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5220, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5221, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5222, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5223, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5224, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5225, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5226, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5227, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5228, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5229, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5230, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5231, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5232, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5233, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5234, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5235, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5236, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5237, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5238, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5239, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5240, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5241, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5242, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5243, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5244, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5245, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5246, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5247, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5248, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5249, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5250, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5251, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5252, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5253, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5254, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5255, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5256, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5257, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5258, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5259, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5260, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5261, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5262, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5263, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5264, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5265, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5266, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5268, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5269, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5270, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5271, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 5272, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 4838, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 4844, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5273, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5274, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5275, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5277, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5278, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 4842, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5279, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5280, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5281, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5282, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 4846, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38051, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38054, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38057, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38060, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38063, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38066, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38069, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38072, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38075, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38078, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38081, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38084, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38087, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38090, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 54477, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 54482, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 54487, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 54492, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 54497, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 54502, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 54507, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 54512, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 54517, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 54522, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 54527, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 54532, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 54537, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 54542, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 54547, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 54552, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 54560, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38183, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38186, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38192, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38195, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38198, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38201, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38204, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38207, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38210, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38213, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38216, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38219, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38222, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38225, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38228, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38231, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38234, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38237, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38240, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38243, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38246, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38249, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38252, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38255, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38258, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38261, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38264, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38270, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38273, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38279, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38282, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38285, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38288, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5523, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5524, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4904, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5525, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 38294, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21913, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21915, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21917, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21919, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21921, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21923, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21925, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21927, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21929, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21931, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21933, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21935, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21937, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21939, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21941, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5179, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5182, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5185, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5187, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5195, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5196, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5199, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5201, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5202, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5204, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5205, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5206, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5207, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5208, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21943, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21945, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21947, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21949, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21951, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21953, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21955, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21957, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21959, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21961, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21963, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21965, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21967, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21969, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 54739, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 54745, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 21982, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4838, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4844, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5273, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5274, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5601, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5602, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4849, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5603, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4861, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4911, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4923, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4922, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4912, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5004, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4869, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4909, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5604, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5605, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5606, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5607, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5608, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5609, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5610, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5611, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5612, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5613, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4875, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5614, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5615, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5616, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5617, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5618, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5619, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5620, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5621, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5275, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5277, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5622, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5623, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5624, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5625, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5626, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5627, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5628, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5629, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5630, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5631, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 22016, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 22018, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 22020, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 22022, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 22024, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 22026, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 22028, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 22030, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 22032, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 22034, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 22036, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 22038, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 22040, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 22042, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 22044, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22046, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22048, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22050, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22052, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22054, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22056, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22058, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22060, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22062, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38448, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38451, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38454, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 22073, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 38459, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 22078, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 38464, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5699, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5700, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5701, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5702, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5703, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5704, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5705, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5706, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5707, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5708, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5709, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5710, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5711, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5712, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5713, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5714, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5715, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5716, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5717, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5718, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5719, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5720, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5721, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5722, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5723, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5724, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5725, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5726, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5727, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5728, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5729, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5730, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5731, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5732, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5733, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5734, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5735, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5736, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5737, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5738, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5739, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5740, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5741, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5742, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5743, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5744, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5745, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22130, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 54900, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 54905, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 54910, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38531, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 54918, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38539, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38542, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 54929, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 54935, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38556, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38559, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38562, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 54949, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 54954, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38575, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38578, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22197, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38583, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 54970, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 54975, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22212, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 54982, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 54988, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 54995, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38617, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55004, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55010, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55016, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38637, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38640, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38643, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55030, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55035, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55041, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38662, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38665, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38668, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22287, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22289, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22291, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22293, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38679, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38682, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55069, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38691, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55078, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55083, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38705, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22324, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22326, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55096, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55102, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55107, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38729, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55116, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22354, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38740, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38743, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38746, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38749, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38752, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55139, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38760, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22379, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38765, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38768, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38771, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55158, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38779, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38782, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38785, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55172, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55178, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22415, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55185, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22423, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55193, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55198, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38819, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38822, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38825, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55212, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22449, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38835, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55222, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22459, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55229, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38851, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22470, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22472, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22474, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22476, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22478, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22480, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22482, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22484, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22486, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22488, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38874, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38877, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38880, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38883, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38886, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38889, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38892, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38895, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38898, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38901, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38904, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38907, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38910, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38913, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 38916, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38919, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22538, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22540, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38926, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22545, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22547, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 22549, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 38935, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 38938, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 22557, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22559, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22561, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22563, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22565, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55335, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22572, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22574, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22576, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22578, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22580, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22582, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22584, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22586, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38972, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55359, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22596, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22598, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22602, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22604, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22606, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22608, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38994, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38997, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39000, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39003, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22622, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22624, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22626, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22628, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22630, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22632, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22634, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22636, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22638, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22640, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39026, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39029, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22648, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39034, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39037, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39040, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22659, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39045, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39048, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55435, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22672, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39058, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39061, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39064, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39067, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55454, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55460, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22699, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22701, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22703, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22705, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22707, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22709, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22711, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22713, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22715, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22717, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22719, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22721, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22723, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22725, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22727, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22729, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22731, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22733, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55503, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22740, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22742, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22744, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55514, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39135, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22754, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22756, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22758, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22760, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22762, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22764, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22766, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22768, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22770, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22772, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39158, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22777, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22779, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39165, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39168, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22787, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 55557, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39178, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22797, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22799, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22803, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 39189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 39192, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22811, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22813, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22815, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22817, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22819, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22821, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22823, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22825, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22827, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39213, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39216, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39219, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39222, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39225, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39228, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39231, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39234, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39237, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39240, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39243, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39246, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39249, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39252, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39255, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39258, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39261, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39264, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39270, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39273, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 39276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 39279, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6514, UINT16_MAX, 6514, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6515, UINT16_MAX, 6515, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6516, UINT16_MAX, 6516, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6517, UINT16_MAX, 6517, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6518, UINT16_MAX, 6518, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6519, UINT16_MAX, 6519, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6520, UINT16_MAX, 6520, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6521, UINT16_MAX, 6521, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6522, UINT16_MAX, 6522, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6523, UINT16_MAX, 6523, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2202, UINT16_MAX, 2202, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2203, UINT16_MAX, 2203, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6524, UINT16_MAX, 6524, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6525, UINT16_MAX, 6525, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6526, UINT16_MAX, 6526, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6527, UINT16_MAX, 6527, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6528, UINT16_MAX, 6528, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6529, UINT16_MAX, 6529, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6530, UINT16_MAX, 6530, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6531, UINT16_MAX, 6531, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6532, UINT16_MAX, 6532, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6533, UINT16_MAX, 6533, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6534, UINT16_MAX, 6534, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6535, UINT16_MAX, 6535, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6536, UINT16_MAX, 6536, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6537, UINT16_MAX, 6537, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6538, UINT16_MAX, 6538, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6539, UINT16_MAX, 6539, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6540, UINT16_MAX, 6540, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6541, UINT16_MAX, 6541, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6542, UINT16_MAX, 6542, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6543, UINT16_MAX, 6543, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6544, UINT16_MAX, 6544, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6545, UINT16_MAX, 6545, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6546, UINT16_MAX, 6546, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6547, UINT16_MAX, 6547, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6548, UINT16_MAX, 6548, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6549, UINT16_MAX, 6549, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6550, UINT16_MAX, 6550, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6551, UINT16_MAX, 6551, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6552, UINT16_MAX, 6552, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6553, UINT16_MAX, 6553, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6554, UINT16_MAX, 6554, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6555, UINT16_MAX, 6555, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6556, UINT16_MAX, 6556, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6557, UINT16_MAX, 6557, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6558, UINT16_MAX, 6558, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6559, UINT16_MAX, 6559, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6560, UINT16_MAX, 6560, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6561, UINT16_MAX, 6561, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6562, UINT16_MAX, 6562, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6563, UINT16_MAX, 6563, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6564, UINT16_MAX, 6564, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6565, UINT16_MAX, 6565, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6566, UINT16_MAX, 6566, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6567, UINT16_MAX, 6567, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6568, UINT16_MAX, 6568, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6569, UINT16_MAX, 6569, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6570, UINT16_MAX, 6570, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6571, UINT16_MAX, 6571, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6572, UINT16_MAX, 6572, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6573, UINT16_MAX, 6573, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6574, UINT16_MAX, 6574, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6575, UINT16_MAX, 6575, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6576, UINT16_MAX, 6576, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6577, UINT16_MAX, 6577, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6578, UINT16_MAX, 6578, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6579, UINT16_MAX, 6579, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6580, UINT16_MAX, 6580, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6581, UINT16_MAX, 6581, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6582, UINT16_MAX, 6582, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6583, UINT16_MAX, 6583, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6584, UINT16_MAX, 6584, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6585, UINT16_MAX, 6585, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1371, UINT16_MAX, 6586, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1373, UINT16_MAX, 6587, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6588, UINT16_MAX, 6588, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6589, UINT16_MAX, 6589, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6590, UINT16_MAX, 6590, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6591, UINT16_MAX, 6591, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6592, UINT16_MAX, 6592, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6593, UINT16_MAX, 6593, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6594, UINT16_MAX, 6594, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6595, UINT16_MAX, 6595, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6596, UINT16_MAX, 6596, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6597, UINT16_MAX, 6597, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6598, UINT16_MAX, 6598, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6599, UINT16_MAX, 6599, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6600, UINT16_MAX, 6600, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6601, UINT16_MAX, 6601, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6602, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6603, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6604, UINT16_MAX, 6604, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6605, UINT16_MAX, 6605, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6606, UINT16_MAX, 6606, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6607, UINT16_MAX, 6607, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6608, UINT16_MAX, 6608, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6609, UINT16_MAX, 6609, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6610, UINT16_MAX, 6610, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6611, UINT16_MAX, 6611, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6612, UINT16_MAX, 6612, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6613, UINT16_MAX, 6613, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6614, UINT16_MAX, 6614, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6615, UINT16_MAX, 6615, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6616, UINT16_MAX, 6616, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6617, UINT16_MAX, 6617, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6618, UINT16_MAX, 6618, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6619, UINT16_MAX, 6619, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6620, UINT16_MAX, 6620, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6621, UINT16_MAX, 6621, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6622, UINT16_MAX, 6622, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6623, UINT16_MAX, 6623, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6624, UINT16_MAX, 6624, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6625, UINT16_MAX, 6625, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6626, UINT16_MAX, 6626, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6627, UINT16_MAX, 6627, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6628, UINT16_MAX, 6628, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6629, UINT16_MAX, 6629, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6630, UINT16_MAX, 6630, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6631, UINT16_MAX, 6631, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6632, UINT16_MAX, 6632, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6633, UINT16_MAX, 6633, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6634, UINT16_MAX, 6634, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6635, UINT16_MAX, 6635, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6636, UINT16_MAX, 6636, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6637, UINT16_MAX, 6637, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6638, UINT16_MAX, 6638, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6639, UINT16_MAX, 6639, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6640, UINT16_MAX, 6640, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6641, UINT16_MAX, 6641, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6642, UINT16_MAX, 6642, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6643, UINT16_MAX, 6643, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6644, UINT16_MAX, 6644, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6645, UINT16_MAX, 6645, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6646, UINT16_MAX, 6646, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6647, UINT16_MAX, 6647, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6648, UINT16_MAX, 6648, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6649, UINT16_MAX, 6649, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6650, UINT16_MAX, 6650, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6651, UINT16_MAX, 6651, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6652, UINT16_MAX, 6652, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6653, UINT16_MAX, 6653, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6654, UINT16_MAX, 6654, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6655, UINT16_MAX, 6655, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6656, UINT16_MAX, 6656, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6657, UINT16_MAX, 6657, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6658, UINT16_MAX, 6658, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6659, UINT16_MAX, 6659, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6660, UINT16_MAX, 6660, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6661, UINT16_MAX, 6661, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6662, UINT16_MAX, 6662, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6663, UINT16_MAX, 6663, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6664, UINT16_MAX, 6664, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6665, UINT16_MAX, 6665, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 6664, UINT16_MAX, 6666, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6667, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6668, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6669, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6670, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6671, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6672, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6673, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6674, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6675, UINT16_MAX, 6675, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6676, UINT16_MAX, 6676, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6677, UINT16_MAX, 6677, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6678, UINT16_MAX, 6678, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6679, UINT16_MAX, 6679, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6680, UINT16_MAX, 6680, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6681, UINT16_MAX, 6681, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6682, UINT16_MAX, 6682, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6683, UINT16_MAX, 6683, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6684, UINT16_MAX, 6684, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6685, UINT16_MAX, 6685, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6686, UINT16_MAX, 6686, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6687, UINT16_MAX, 6687, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6688, UINT16_MAX, 6688, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6689, UINT16_MAX, 6689, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6690, UINT16_MAX, 6690, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6691, UINT16_MAX, 6691, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2372, UINT16_MAX, 2372, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6692, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6693, UINT16_MAX, 6693, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6694, UINT16_MAX, 6694, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6695, UINT16_MAX, 6695, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6696, UINT16_MAX, 6696, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6697, UINT16_MAX, 6697, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6698, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6699, UINT16_MAX, 6699, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6700, UINT16_MAX, 6700, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6701, UINT16_MAX, 6701, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6702, UINT16_MAX, 6702, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6703, UINT16_MAX, 6703, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6704, UINT16_MAX, 6704, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6705, UINT16_MAX, 6705, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6706, UINT16_MAX, 6706, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6707, UINT16_MAX, 6707, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6708, UINT16_MAX, 6708, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6709, UINT16_MAX, 6709, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6710, UINT16_MAX, 6710, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6711, UINT16_MAX, 6711, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6712, UINT16_MAX, 6712, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6713, UINT16_MAX, 6713, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6714, UINT16_MAX, 6714, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6715, UINT16_MAX, 6715, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6716, UINT16_MAX, 6716, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6717, UINT16_MAX, 6717, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6718, UINT16_MAX, 6718, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1105, UINT16_MAX, 1105, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2282, UINT16_MAX, 2282, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2370, UINT16_MAX, 2370, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6719, UINT16_MAX, 6719, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2376, UINT16_MAX, 2376, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6720, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6721, UINT16_MAX, 6721, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6722, UINT16_MAX, 6722, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2379, UINT16_MAX, 2379, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6723, UINT16_MAX, 6723, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6724, UINT16_MAX, 6724, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6725, UINT16_MAX, 6725, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6726, UINT16_MAX, 6726, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6727, UINT16_MAX, 6727, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6728, UINT16_MAX, 6728, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6729, UINT16_MAX, 6729, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6730, UINT16_MAX, 6730, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6731, UINT16_MAX, 6731, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6732, UINT16_MAX, 6732, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6733, UINT16_MAX, 6733, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6734, UINT16_MAX, 6734, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6735, UINT16_MAX, 6735, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6736, UINT16_MAX, 6736, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6737, UINT16_MAX, 6737, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6738, UINT16_MAX, 6738, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6739, UINT16_MAX, 6739, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6740, UINT16_MAX, 6740, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2392, UINT16_MAX, 2392, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6741, UINT16_MAX, 6741, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6742, UINT16_MAX, 6742, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6743, UINT16_MAX, 6743, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6744, UINT16_MAX, 6744, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6745, UINT16_MAX, 6745, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6746, UINT16_MAX, 6746, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6747, UINT16_MAX, 6747, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6748, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6749, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6750, UINT16_MAX, 6750, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6751, UINT16_MAX, 6751, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6752, UINT16_MAX, 6752, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6753, UINT16_MAX, 6753, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 28, UINT16_MAX, 6754, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 31, UINT16_MAX, 6755, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 42, UINT16_MAX, 6756, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6757, UINT16_MAX, 6757, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6758, UINT16_MAX, 6758, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 358, UINT16_MAX, 6759, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 473, UINT16_MAX, 6760, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6761, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6762, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6763, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6764, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6765, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6766, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6767, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6768, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6769, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6770, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6771, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6772, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6773, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6774, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6775, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6776, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6777, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6778, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6779, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6780, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6781, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6782, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6783, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6784, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6785, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6786, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6787, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6788, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6789, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6790, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6791, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6792, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6793, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6794, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6795, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6796, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6797, UINT16_MAX, 6797, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6798, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6799, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6800, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6801, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6802, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6803, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6804, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 6592, UINT16_MAX, 6805, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 6769, UINT16_MAX, 6806, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 4662, UINT16_MAX, 6807, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 6796, UINT16_MAX, 6808, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6809, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6810, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6811, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6812, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6813, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6814, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6815, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6816, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 6817, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1070, UINT16_MAX, 6818, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6819, 6819, UINT16_MAX, 6819, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6820, 6820, UINT16_MAX, 6820, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6821, 6821, UINT16_MAX, 6821, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6822, 6822, UINT16_MAX, 6822, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6823, 6823, UINT16_MAX, 6823, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6824, 6824, UINT16_MAX, 6824, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6825, 6825, UINT16_MAX, 6825, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6826, 6826, UINT16_MAX, 6826, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6827, 6827, UINT16_MAX, 6827, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6828, 6828, UINT16_MAX, 6828, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6829, 6829, UINT16_MAX, 6829, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6830, 6830, UINT16_MAX, 6830, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6831, 6831, UINT16_MAX, 6831, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6832, 6832, UINT16_MAX, 6832, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6833, 6833, UINT16_MAX, 6833, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6834, 6834, UINT16_MAX, 6834, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6835, 6835, UINT16_MAX, 6835, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6836, 6836, UINT16_MAX, 6836, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6837, 6837, UINT16_MAX, 6837, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6838, 6838, UINT16_MAX, 6838, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6839, 6839, UINT16_MAX, 6839, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6840, 6840, UINT16_MAX, 6840, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6841, 6841, UINT16_MAX, 6841, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6842, 6842, UINT16_MAX, 6842, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6843, 6843, UINT16_MAX, 6843, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6844, 6844, UINT16_MAX, 6844, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6845, 6845, UINT16_MAX, 6845, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6846, 6846, UINT16_MAX, 6846, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6847, 6847, UINT16_MAX, 6847, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6848, 6848, UINT16_MAX, 6848, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6849, 6849, UINT16_MAX, 6849, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6850, 6850, UINT16_MAX, 6850, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6851, 6851, UINT16_MAX, 6851, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6852, 6852, UINT16_MAX, 6852, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6853, 6853, UINT16_MAX, 6853, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6854, 6854, UINT16_MAX, 6854, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6855, 6855, UINT16_MAX, 6855, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6856, 6856, UINT16_MAX, 6856, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6857, 6857, UINT16_MAX, 6857, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6858, 6858, UINT16_MAX, 6858, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6859, 6859, UINT16_MAX, 6859, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6860, 6860, UINT16_MAX, 6860, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6861, 6861, UINT16_MAX, 6861, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6862, 6862, UINT16_MAX, 6862, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6863, 6863, UINT16_MAX, 6863, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6864, 6864, UINT16_MAX, 6864, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6865, 6865, UINT16_MAX, 6865, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6866, 6866, UINT16_MAX, 6866, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6867, 6867, UINT16_MAX, 6867, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6868, 6868, UINT16_MAX, 6868, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6869, 6869, UINT16_MAX, 6869, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6870, 6870, UINT16_MAX, 6870, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6871, 6871, UINT16_MAX, 6871, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6872, 6872, UINT16_MAX, 6872, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6873, 6873, UINT16_MAX, 6873, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6874, 6874, UINT16_MAX, 6874, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6875, 6875, UINT16_MAX, 6875, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6876, 6876, UINT16_MAX, 6876, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6877, 6877, UINT16_MAX, 6877, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6878, 6878, UINT16_MAX, 6878, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6879, 6879, UINT16_MAX, 6879, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6880, 6880, UINT16_MAX, 6880, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6881, 6881, UINT16_MAX, 6881, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6882, 6882, UINT16_MAX, 6882, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6883, 6883, UINT16_MAX, 6883, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6884, 6884, UINT16_MAX, 6884, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6885, 6885, UINT16_MAX, 6885, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6886, 6886, UINT16_MAX, 6886, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6887, 6887, UINT16_MAX, 6887, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6888, 6888, UINT16_MAX, 6888, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6889, 6889, UINT16_MAX, 6889, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6890, 6890, UINT16_MAX, 6890, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6891, 6891, UINT16_MAX, 6891, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6892, 6892, UINT16_MAX, 6892, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6893, 6893, UINT16_MAX, 6893, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6894, 6894, UINT16_MAX, 6894, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6895, 6895, UINT16_MAX, 6895, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6896, 6896, UINT16_MAX, 6896, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6897, 6897, UINT16_MAX, 6897, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6898, 6898, UINT16_MAX, 6898, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_LV, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_LVT, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_CS, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_CO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6899, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6900, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4996, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6901, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6902, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6903, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6904, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5050, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6905, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5004, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6906, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6907, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6908, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6909, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6910, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6911, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6912, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6913, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6914, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6915, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6916, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6917, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6918, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6919, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6920, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6921, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6922, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6923, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6924, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6925, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6926, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6927, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6928, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6929, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6930, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6931, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6932, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6933, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6934, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6935, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6936, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6937, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6938, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6939, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6940, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6941, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6942, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6943, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6944, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6945, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6946, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4962, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6947, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6948, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6949, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6950, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6951, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6952, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6953, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6954, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6955, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6956, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6957, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5035, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6958, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6959, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6960, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6961, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6962, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6963, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6964, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6965, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6966, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6967, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6968, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6969, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6970, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6971, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6972, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6973, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6974, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6975, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6976, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6977, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6978, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6979, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6980, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6981, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6982, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6983, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6984, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6985, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6986, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6987, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6988, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6989, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6990, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6991, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6992, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6993, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6994, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6995, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6996, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6997, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6998, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 6999, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7000, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7001, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7002, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7003, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7004, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4998, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7005, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7006, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7007, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7008, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7009, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7010, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7011, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7012, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7013, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7014, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7015, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7016, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7017, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7018, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7019, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4875, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7020, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7021, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7022, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7023, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7024, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7025, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7026, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7027, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4856, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7028, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7029, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7030, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7031, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7032, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7033, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7034, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7035, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7036, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7037, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7038, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7039, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7040, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7041, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7042, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7043, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7044, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7045, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7046, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7047, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7048, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7049, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7050, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7051, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7052, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7053, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7054, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7055, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7056, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7057, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7058, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7059, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7060, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7061, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7062, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7063, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7064, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7065, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7066, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7067, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7068, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7069, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7070, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7071, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7072, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7073, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7074, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7075, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7076, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7077, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7078, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7079, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7080, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7081, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5049, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7082, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7083, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7084, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7085, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7086, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7087, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7088, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7089, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7090, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7091, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7092, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7093, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5601, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7094, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7095, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7096, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7097, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7098, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7099, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7100, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7101, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7102, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7103, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7104, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7105, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7106, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7107, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7108, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7109, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7110, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7111, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7112, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7113, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7114, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7115, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5003, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7116, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7117, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7118, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7119, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7120, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7121, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7122, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7123, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7124, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7125, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7126, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7127, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7128, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4954, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7129, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7130, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7131, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7132, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7133, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7134, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7135, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7136, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7137, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7138, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7139, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7140, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7141, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7142, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7143, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7144, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4981, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7145, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4984, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7146, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7147, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7148, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7149, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7150, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7151, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7152, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7153, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7154, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7155, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7156, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7157, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7158, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7159, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4961, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7160, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7161, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7162, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7163, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7164, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7165, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7166, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7167, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7168, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7169, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7170, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7171, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7172, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7173, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7174, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7175, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7176, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7177, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7178, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7179, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7180, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7181, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4882, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7182, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7183, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7184, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7185, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7186, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7187, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7188, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7190, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7191, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7192, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7193, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7194, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7195, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7196, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5606, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7197, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7198, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7199, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7200, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5610, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7201, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7202, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7203, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7204, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7205, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7206, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7207, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7208, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7209, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7210, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7211, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7212, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7213, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7214, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7215, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7216, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7217, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7218, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7219, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7220, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7221, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7222, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7223, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7224, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7226, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7227, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7228, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7229, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7230, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7231, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7232, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7233, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7234, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7235, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7236, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7237, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7238, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7239, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7240, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7241, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7242, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7243, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7244, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7245, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7246, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7247, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7248, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7249, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7250, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7251, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7252, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7253, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7254, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7255, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7256, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7257, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4915, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7258, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7259, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7260, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7261, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7262, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7263, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7264, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7265, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7266, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7268, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7269, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7270, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7271, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7272, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7273, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7274, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7275, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7277, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7278, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7279, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7280, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7281, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7282, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7283, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7284, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7285, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7286, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7287, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7288, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7289, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7290, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7291, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7292, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7293, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7294, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7295, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7297, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7299, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7301, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7302, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7303, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7304, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7306, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7308, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7310, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7311, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23696, 23696, 7314, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23699, 23699, 7317, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23702, 23702, 7320, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 40089, 40089, 7324, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 40093, 40093, 7328, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23713, 23715, 7333, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23715, 23715, 7334, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23719, 23719, 7337, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23722, 23722, 7340, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23725, 23725, 7343, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23728, 23728, 7346, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23731, 23731, 7349, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23734, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 26, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23736, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 7354, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 4011, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 4014, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 7355, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 7356, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 7357, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 7358, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 7359, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 7360, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_FONT, 3937, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23745, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23747, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23749, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23751, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23753, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23755, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23757, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23759, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23761, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23763, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23765, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23767, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23769, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23771, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23773, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23775, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23777, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23779, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23781, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23783, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23785, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23787, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23789, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23791, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23793, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23795, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23797, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23799, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23803, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23805, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 23807, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_COMPAT, 23809, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7427, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7427, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7428, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7428, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7428, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7428, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7429, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7429, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7429, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7429, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7430, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7430, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7430, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7430, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7431, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7431, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7431, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7431, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7432, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7432, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7432, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7432, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7433, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7433, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7433, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7433, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7434, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7434, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7434, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7434, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7435, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7435, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7435, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7435, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7436, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7436, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7436, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7436, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7437, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7437, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7437, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7437, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7438, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7438, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7438, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7438, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7439, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7439, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7439, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7439, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7440, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7440, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7441, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7441, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7442, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7442, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7443, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7443, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7444, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7444, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7445, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7445, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7446, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7446, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7446, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7446, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7447, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7447, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7447, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7447, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7448, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7448, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7448, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7448, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7449, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7449, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7449, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7449, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7450, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7450, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7451, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7451, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7451, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7451, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7452, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7452, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7453, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7453, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7453, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7453, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7454, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7454, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7454, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7454, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7455, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7455, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7456, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7456, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7457, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7457, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7457, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7457, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7458, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7458, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7459, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7459, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7460, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7460, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7461, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7462, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7462, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7463, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7463, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7464, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7464, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7465, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7465, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7465, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7465, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7466, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7466, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23851, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23851, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23853, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23853, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23855, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23855, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23857, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23857, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23859, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23859, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23861, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23861, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23863, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23863, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23863, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23865, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23865, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23865, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7483, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7483, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 7483, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 7483, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23868, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23870, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23872, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23874, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23876, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23878, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23880, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23882, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23884, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23886, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23888, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23890, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23892, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23894, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23896, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23898, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23900, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23902, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23904, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23906, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23908, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23910, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23912, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23914, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23916, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23918, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23920, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23922, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23924, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23926, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23928, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23930, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23932, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23934, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23936, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23938, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23940, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23942, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23944, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23946, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23948, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23950, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23952, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23954, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23956, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23958, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23960, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23962, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23964, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23966, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23968, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23970, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23972, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23974, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23976, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23978, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23980, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23982, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23984, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23986, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23988, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23990, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23992, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23994, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23996, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 23998, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24000, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24002, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24004, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24006, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24008, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24010, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24012, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24014, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24016, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24018, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24020, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24022, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24024, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24026, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24028, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24030, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24032, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24034, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24036, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24038, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24040, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24042, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24044, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24046, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24048, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24050, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24052, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 40438, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 40441, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 40444, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 40447, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 40450, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 40453, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24072, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24074, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23872, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24076, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23874, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24078, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24080, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23882, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24082, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23884, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23886, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24084, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24086, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23894, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24088, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23896, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23898, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24090, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24092, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23902, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24094, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23904, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23906, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23964, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23966, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23972, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23974, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23976, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23984, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23986, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23988, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23990, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 23998, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24000, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24002, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24096, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24010, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24098, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24100, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24022, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24102, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24024, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24026, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24052, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24104, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24106, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24042, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24108, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24044, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24046, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23868, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23870, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24110, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23872, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24112, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23876, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23878, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23880, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23882, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24114, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23888, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23890, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23892, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23894, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24116, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23902, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23908, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23910, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23912, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23914, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23916, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23920, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23922, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23924, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23926, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23928, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23930, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24118, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23932, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23934, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23936, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23938, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23940, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23942, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23946, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23948, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23950, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23952, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23954, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23956, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23958, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23960, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23962, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23968, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23970, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23978, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23980, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23982, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23984, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23986, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23992, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23994, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23996, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23998, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24120, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24004, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24006, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24008, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24010, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24016, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24018, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24020, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24022, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24122, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24028, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24030, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24124, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24036, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24038, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24040, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24042, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24126, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 23872, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24112, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 23882, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24114, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 23894, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24116, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 23902, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24128, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 23928, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24130, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24132, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24134, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 23984, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 23986, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 23998, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24022, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24122, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24042, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24126, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 40520, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 40523, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 40526, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24145, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24147, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24149, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24151, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24153, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24155, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24157, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24159, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24161, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24163, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24165, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24167, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24169, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24171, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24173, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24175, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24177, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24179, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24181, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24183, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24185, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24187, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24132, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24191, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24193, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24195, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24197, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24145, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24147, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24149, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24151, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24153, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24155, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24157, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24159, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24161, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24163, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24165, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24167, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24169, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24171, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24173, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24175, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24177, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24179, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24181, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24183, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24185, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24187, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24132, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24191, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24193, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24195, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24197, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24185, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24187, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24132, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24130, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 24134, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 23944, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 23922, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 23924, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 23926, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24185, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24187, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 23944, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 23946, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24199, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24199, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40585, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40588, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40588, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40591, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40594, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40597, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40603, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40606, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40606, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40609, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40612, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40615, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40618, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40621, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40624, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40624, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40627, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40630, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40630, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40633, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40633, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40636, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40639, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40639, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40642, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40645, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40645, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40648, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40648, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40651, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40654, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40654, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40657, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40657, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40660, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40663, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40666, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40669, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40669, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40672, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40675, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40678, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40681, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40684, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40684, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40687, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40690, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40693, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40696, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40699, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40702, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40702, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40705, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40705, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40708, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40708, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40711, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40714, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40717, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40720, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40723, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40726, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40729, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40732, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40735, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40738, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40741, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40744, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40747, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40747, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40750, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40753, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40756, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40759, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40759, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40762, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40765, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40768, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40771, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40774, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40777, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40780, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40783, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40786, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40789, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40792, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40795, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40798, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40804, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40807, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40810, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40813, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40816, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40819, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40822, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40825, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40687, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40693, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40828, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40831, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40834, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40837, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40840, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40843, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40840, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40834, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40846, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40849, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40852, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40855, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40858, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40843, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40666, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 40636, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40861, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 40864, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 40867, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 40870, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 57257, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 57262, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 57267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 57272, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 57277, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 57282, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 57287, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 40908, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 57295, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 57314, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 57323, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8176, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8177, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8178, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8179, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 1153, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8180, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8181, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8182, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8183, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8184, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8185, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8186, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8187, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PC, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8188, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 3940, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 3941, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8190, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8191, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8192, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8193, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8194, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8195, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8196, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 4262, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 4263, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8197, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8198, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8199, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8200, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8201, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 8202, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 8203, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PC, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 8188, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_SMALL, 8176, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 8177, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_SMALL, 3898, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 1153, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_SMALL, 8179, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 8181, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 8180, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 8186, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 3940, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 3941, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 8189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 8190, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 8191, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 8192, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_SMALL, 8204, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 8205, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 8206, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_SMALL, 3937, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_SMALL, 8207, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 8208, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 8209, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 3939, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 8210, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_SMALL, 8211, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_SMALL, 8212, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 8213, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24598, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24602, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24604, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24606, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24608, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24610, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24612, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24614, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24616, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24618, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24620, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24622, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 24624, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8242, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8243, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8243, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8244, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8244, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8245, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8245, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8246, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8246, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8247, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8247, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8247, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8247, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8248, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8248, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8249, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8249, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8249, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8249, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8250, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8250, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8251, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8251, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8251, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8251, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8252, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8252, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8252, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8252, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8253, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8253, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8253, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8253, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8254, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8254, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8254, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8254, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8255, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8255, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8255, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8255, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8256, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8256, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8257, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8257, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8258, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8258, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8259, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8259, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8260, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8260, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8260, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8260, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8261, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8261, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8261, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8261, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8262, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8262, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8262, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8262, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8263, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8263, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8263, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8263, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8264, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8264, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8264, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8264, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8265, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8265, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8265, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8265, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8266, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8266, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8266, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8266, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8268, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8268, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8268, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8268, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8269, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8269, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8269, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8269, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8270, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8270, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8270, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8270, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8271, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8271, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8271, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8271, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8272, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8272, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8272, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8272, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8273, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8273, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8273, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8273, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8274, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8274, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8274, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8274, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8275, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8275, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 7466, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 7466, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 8276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 8276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 8276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 8276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24661, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24661, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24663, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24663, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24665, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24665, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 24667, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 24667, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8180, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8285, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_WIDE, 8204, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_WIDE, 8211, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_WIDE, 8212, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8205, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8286, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 3940, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 3941, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8206, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_WIDE, 3937, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_WIDE, 8176, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_WIDE, 8207, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_WIDE, 3898, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_WIDE, 8287, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 3929, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 66, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 58, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 59, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 3931, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 3932, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 3933, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 3934, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 3935, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 3936, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_WIDE, 8179, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 1153, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8208, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 3939, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8209, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8181, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8213, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 26, 8288, UINT16_MAX, 8288, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 27, 8289, UINT16_MAX, 8289, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 28, 8290, UINT16_MAX, 8290, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 29, 8291, UINT16_MAX, 8291, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 30, 8292, UINT16_MAX, 8292, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 31, 8293, UINT16_MAX, 8293, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 32, 8294, UINT16_MAX, 8294, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 33, 8295, UINT16_MAX, 8295, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 34, 8296, UINT16_MAX, 8296, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 35, 8297, UINT16_MAX, 8297, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 36, 8298, UINT16_MAX, 8298, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 37, 8299, UINT16_MAX, 8299, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 38, 8300, UINT16_MAX, 8300, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 39, 8301, UINT16_MAX, 8301, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 40, 8302, UINT16_MAX, 8302, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 41, 8303, UINT16_MAX, 8303, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 42, 8304, UINT16_MAX, 8304, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 43, 8305, UINT16_MAX, 8305, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 44, 8306, UINT16_MAX, 8306, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 45, 8307, UINT16_MAX, 8307, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 46, 8308, UINT16_MAX, 8308, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 47, 8309, UINT16_MAX, 8309, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 48, 8310, UINT16_MAX, 8310, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 49, 8311, UINT16_MAX, 8311, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 50, 8312, UINT16_MAX, 8312, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 51, 8313, UINT16_MAX, 8313, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8201, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8210, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8202, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8314, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PC, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8188, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 3854, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 0, UINT16_MAX, 8315, UINT16_MAX, 8315, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1, UINT16_MAX, 8316, UINT16_MAX, 8316, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 2, UINT16_MAX, 8317, UINT16_MAX, 8317, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 3, UINT16_MAX, 8318, UINT16_MAX, 8318, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 4, UINT16_MAX, 8319, UINT16_MAX, 8319, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 5, UINT16_MAX, 8320, UINT16_MAX, 8320, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 6, UINT16_MAX, 8321, UINT16_MAX, 8321, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 7, UINT16_MAX, 8322, UINT16_MAX, 8322, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 8, UINT16_MAX, 8323, UINT16_MAX, 8323, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 9, UINT16_MAX, 8324, UINT16_MAX, 8324, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 10, UINT16_MAX, 8325, UINT16_MAX, 8325, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 11, UINT16_MAX, 8326, UINT16_MAX, 8326, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 12, UINT16_MAX, 8327, UINT16_MAX, 8327, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 13, UINT16_MAX, 8328, UINT16_MAX, 8328, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 14, UINT16_MAX, 8329, UINT16_MAX, 8329, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 15, UINT16_MAX, 8330, UINT16_MAX, 8330, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 16, UINT16_MAX, 8331, UINT16_MAX, 8331, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 17, UINT16_MAX, 8332, UINT16_MAX, 8332, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 18, UINT16_MAX, 8333, UINT16_MAX, 8333, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 19, UINT16_MAX, 8334, UINT16_MAX, 8334, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 20, UINT16_MAX, 8335, UINT16_MAX, 8335, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 21, UINT16_MAX, 8336, UINT16_MAX, 8336, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 22, UINT16_MAX, 8337, UINT16_MAX, 8337, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 23, UINT16_MAX, 8338, UINT16_MAX, 8338, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 24, UINT16_MAX, 8339, UINT16_MAX, 8339, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 25, UINT16_MAX, 8340, UINT16_MAX, 8340, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8341, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8190, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8342, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8343, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8344, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 8178, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 8197, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 8198, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 8177, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 8345, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5745, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8346, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8347, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8348, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8349, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8350, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8351, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8352, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8353, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8354, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8355, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5699, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5700, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5701, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5702, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5703, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5704, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5705, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5706, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5707, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5708, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5709, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5710, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5711, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5712, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5713, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5714, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5715, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5716, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5717, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5718, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5719, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5720, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5721, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5722, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5723, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5724, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5725, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5726, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5727, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5728, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5729, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5730, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5731, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5732, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5733, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5734, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5735, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5736, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5737, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5738, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5739, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5740, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5741, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 5742, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8356, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8357, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8358, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8359, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8360, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8361, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8362, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8363, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8364, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8365, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8366, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8367, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8368, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8369, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8370, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8371, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8372, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8373, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8374, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8375, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8376, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8377, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8378, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8379, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8380, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8381, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8382, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8383, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8384, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8385, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8386, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8387, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8388, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8389, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8390, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8391, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8392, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8393, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8394, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8395, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8396, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8397, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8398, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8399, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8400, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8401, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8402, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8403, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8404, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8405, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8406, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8407, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8408, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8409, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 8410, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_WIDE, 8411, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_WIDE, 8412, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8413, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8414, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 8415, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_WIDE, 8416, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_WIDE, 8417, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 8418, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 8419, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 8420, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 8421, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 8422, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 8423, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 8424, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8425, UINT16_MAX, 8425, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8427, UINT16_MAX, 8427, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8429, UINT16_MAX, 8429, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8431, UINT16_MAX, 8431, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8433, UINT16_MAX, 8433, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8435, UINT16_MAX, 8435, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8437, UINT16_MAX, 8437, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8439, UINT16_MAX, 8439, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8441, UINT16_MAX, 8441, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8443, UINT16_MAX, 8443, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8445, UINT16_MAX, 8445, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8447, UINT16_MAX, 8447, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8449, UINT16_MAX, 8449, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8451, UINT16_MAX, 8451, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8453, UINT16_MAX, 8453, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8455, UINT16_MAX, 8455, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8457, UINT16_MAX, 8457, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8459, UINT16_MAX, 8459, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8461, UINT16_MAX, 8461, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8463, UINT16_MAX, 8463, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8465, UINT16_MAX, 8465, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8467, UINT16_MAX, 8467, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8469, UINT16_MAX, 8469, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8471, UINT16_MAX, 8471, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8473, UINT16_MAX, 8473, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8475, UINT16_MAX, 8475, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8477, UINT16_MAX, 8477, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8479, UINT16_MAX, 8479, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8481, UINT16_MAX, 8481, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8483, UINT16_MAX, 8483, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8485, UINT16_MAX, 8485, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8487, UINT16_MAX, 8487, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8489, UINT16_MAX, 8489, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8491, UINT16_MAX, 8491, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8493, UINT16_MAX, 8493, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8495, UINT16_MAX, 8495, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8497, UINT16_MAX, 8497, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8499, UINT16_MAX, 8499, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8501, UINT16_MAX, 8501, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8503, UINT16_MAX, 8503, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8505, UINT16_MAX, 8505, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8507, UINT16_MAX, 8507, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8509, UINT16_MAX, 8509, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8511, UINT16_MAX, 8511, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8513, UINT16_MAX, 8513, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8515, UINT16_MAX, 8515, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8517, UINT16_MAX, 8517, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8519, UINT16_MAX, 8519, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8521, UINT16_MAX, 8521, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8523, UINT16_MAX, 8523, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8525, UINT16_MAX, 8525, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8527, UINT16_MAX, 8527, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8529, UINT16_MAX, 8529, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8531, UINT16_MAX, 8531, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8533, UINT16_MAX, 8533, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8535, UINT16_MAX, 8535, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8537, UINT16_MAX, 8537, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8539, UINT16_MAX, 8539, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8541, UINT16_MAX, 8541, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8543, UINT16_MAX, 8543, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8545, UINT16_MAX, 8545, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8547, UINT16_MAX, 8547, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8549, UINT16_MAX, 8549, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8551, UINT16_MAX, 8551, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8553, UINT16_MAX, 8553, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8555, UINT16_MAX, 8555, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8557, UINT16_MAX, 8557, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8559, UINT16_MAX, 8559, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8561, UINT16_MAX, 8561, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8563, UINT16_MAX, 8563, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8565, UINT16_MAX, 8565, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8567, UINT16_MAX, 8567, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8569, UINT16_MAX, 8569, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8571, UINT16_MAX, 8571, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8573, UINT16_MAX, 8573, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8575, UINT16_MAX, 8575, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8577, UINT16_MAX, 8577, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8579, UINT16_MAX, 8579, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8581, UINT16_MAX, 8581, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8583, UINT16_MAX, 8583, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8585, UINT16_MAX, 8585, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8587, UINT16_MAX, 8587, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8589, UINT16_MAX, 8589, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8591, UINT16_MAX, 8591, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8593, UINT16_MAX, 8593, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8595, UINT16_MAX, 8595, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8597, UINT16_MAX, 8597, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8599, UINT16_MAX, 8599, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8601, UINT16_MAX, 8601, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8603, UINT16_MAX, 8603, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8605, UINT16_MAX, 8605, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8607, UINT16_MAX, 8607, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8609, UINT16_MAX, 8609, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8611, UINT16_MAX, 8611, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8613, UINT16_MAX, 8613, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8615, UINT16_MAX, 8615, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8617, UINT16_MAX, 8617, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8619, UINT16_MAX, 8619, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8621, UINT16_MAX, 8621, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8623, UINT16_MAX, 8623, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8625, UINT16_MAX, 8625, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8627, UINT16_MAX, 8627, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8629, UINT16_MAX, 8629, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8631, UINT16_MAX, 8631, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8633, UINT16_MAX, 8633, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8635, UINT16_MAX, 8635, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8637, UINT16_MAX, 8637, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8639, UINT16_MAX, 8639, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8641, UINT16_MAX, 8641, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8643, UINT16_MAX, 8643, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8645, UINT16_MAX, 8645, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8647, UINT16_MAX, 8647, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8649, UINT16_MAX, 8649, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8651, UINT16_MAX, 8651, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8653, UINT16_MAX, 8653, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8655, UINT16_MAX, 8655, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8657, UINT16_MAX, 8657, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8659, UINT16_MAX, 8659, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8661, UINT16_MAX, 8661, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8663, UINT16_MAX, 8663, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8665, UINT16_MAX, 8665, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8667, UINT16_MAX, 8667, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8669, UINT16_MAX, 8669, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8671, UINT16_MAX, 8671, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8673, UINT16_MAX, 8673, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8675, UINT16_MAX, 8675, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8677, UINT16_MAX, 8677, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8679, UINT16_MAX, 8679, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8681, UINT16_MAX, 8681, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8683, UINT16_MAX, 8683, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8685, UINT16_MAX, 8685, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8687, UINT16_MAX, 8687, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8689, UINT16_MAX, 8689, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8691, UINT16_MAX, 8691, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8693, UINT16_MAX, 8693, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8695, UINT16_MAX, 8695, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8697, UINT16_MAX, 8697, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8699, UINT16_MAX, 8699, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8701, UINT16_MAX, 8701, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8703, UINT16_MAX, 8703, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8705, UINT16_MAX, 8705, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8707, UINT16_MAX, 8707, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8709, UINT16_MAX, 8709, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8711, UINT16_MAX, 8711, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8713, UINT16_MAX, 8713, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8715, UINT16_MAX, 8715, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8717, UINT16_MAX, 8717, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8719, UINT16_MAX, 8719, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8721, UINT16_MAX, 8721, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8723, UINT16_MAX, 8723, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8725, UINT16_MAX, 8725, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8727, UINT16_MAX, 8727, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8729, UINT16_MAX, 8729, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8731, UINT16_MAX, 8731, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8733, UINT16_MAX, 8733, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8735, UINT16_MAX, 8735, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8737, UINT16_MAX, 8737, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8739, UINT16_MAX, 8739, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8741, UINT16_MAX, 8741, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8743, UINT16_MAX, 8743, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8745, UINT16_MAX, 8745, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8747, UINT16_MAX, 8747, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8749, UINT16_MAX, 8749, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8751, UINT16_MAX, 8751, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8753, UINT16_MAX, 8753, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8755, UINT16_MAX, 8755, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8757, UINT16_MAX, 8757, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8759, UINT16_MAX, 8759, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8761, UINT16_MAX, 8761, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8763, UINT16_MAX, 8763, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8765, UINT16_MAX, 8765, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8767, UINT16_MAX, 8767, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8769, UINT16_MAX, 8769, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8771, UINT16_MAX, 8771, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8773, UINT16_MAX, 8773, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8775, UINT16_MAX, 8775, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8777, UINT16_MAX, 8777, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8779, UINT16_MAX, 8779, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8781, UINT16_MAX, 8781, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8783, UINT16_MAX, 8783, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8785, UINT16_MAX, 8785, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8787, UINT16_MAX, 8787, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8789, UINT16_MAX, 8789, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8791, UINT16_MAX, 8791, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8793, UINT16_MAX, 8793, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8795, UINT16_MAX, 8795, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8797, UINT16_MAX, 8797, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8799, UINT16_MAX, 8799, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8801, UINT16_MAX, 8801, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8803, UINT16_MAX, 8803, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8805, UINT16_MAX, 8805, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8807, UINT16_MAX, 8807, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8809, UINT16_MAX, 8809, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8811, UINT16_MAX, 8811, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8813, UINT16_MAX, 8813, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8815, UINT16_MAX, 8815, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8817, UINT16_MAX, 8817, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8819, UINT16_MAX, 8819, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8821, UINT16_MAX, 8821, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8823, UINT16_MAX, 8823, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8825, UINT16_MAX, 8825, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8827, UINT16_MAX, 8827, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8829, UINT16_MAX, 8829, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8831, UINT16_MAX, 8831, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8833, UINT16_MAX, 8833, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8835, UINT16_MAX, 8835, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8837, UINT16_MAX, 8837, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8839, UINT16_MAX, 8839, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8841, UINT16_MAX, 8841, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8843, UINT16_MAX, 8843, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8845, UINT16_MAX, 8845, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8847, UINT16_MAX, 8847, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8849, UINT16_MAX, 8849, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8851, UINT16_MAX, 8851, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8853, UINT16_MAX, 8853, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8855, UINT16_MAX, 8855, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8857, UINT16_MAX, 8857, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8859, UINT16_MAX, 8859, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8861, UINT16_MAX, 8861, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8863, UINT16_MAX, 8863, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8865, UINT16_MAX, 8865, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8867, UINT16_MAX, 8867, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8869, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 8871, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 8872, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 95, UINT16_MAX, 8873, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1081, UINT16_MAX, 8875, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 601, UINT16_MAX, 8877, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1091, UINT16_MAX, 8879, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 6815, UINT16_MAX, 8881, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1093, UINT16_MAX, 8883, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1092, UINT16_MAX, 8885, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 609, UINT16_MAX, 8887, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 610, UINT16_MAX, 8889, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2352, UINT16_MAX, 8891, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1017, UINT16_MAX, 8893, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1023, UINT16_MAX, 8895, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1097, UINT16_MAX, 8897, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1029, UINT16_MAX, 8899, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1027, UINT16_MAX, 8901, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 619, UINT16_MAX, 8903, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1083, UINT16_MAX, 8905, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 357, UINT16_MAX, 8907, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1084, UINT16_MAX, 8909, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1032, UINT16_MAX, 8911, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1061, UINT16_MAX, 8913, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1098, UINT16_MAX, 8915, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1099, UINT16_MAX, 8917, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 6719, UINT16_MAX, 8919, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 8921, UINT16_MAX, 8923, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 6692, UINT16_MAX, 8925, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1039, UINT16_MAX, 8927, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 8929, UINT16_MAX, 8931, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1071, UINT16_MAX, 8933, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 8935, UINT16_MAX, 8937, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 142, UINT16_MAX, 8939, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1047, UINT16_MAX, 8941, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1048, UINT16_MAX, 8943, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 16, UINT16_MAX, 8945, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1051, UINT16_MAX, 8947, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 8949, UINT16_MAX, 8951, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 4664, UINT16_MAX, 8953, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1055, UINT16_MAX, 8955, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 642, UINT16_MAX, 8957, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1096, UINT16_MAX, 8959, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1094, UINT16_MAX, 8961, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 6816, UINT16_MAX, 8963, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1095, UINT16_MAX, 8965, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 650, UINT16_MAX, 8967, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 4673, UINT16_MAX, 8969, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1072, UINT16_MAX, 8971, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1089, UINT16_MAX, 8973, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1090, UINT16_MAX, 8975, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1080, UINT16_MAX, 8977, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 8979, UINT16_MAX, 8980, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 8982, UINT16_MAX, 8983, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 8985, UINT16_MAX, 8986, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 8988, UINT16_MAX, 8990, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 8992, UINT16_MAX, 8994, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 8996, UINT16_MAX, 8996, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 8998, UINT16_MAX, 8998, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9000, UINT16_MAX, 9000, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9002, UINT16_MAX, 9002, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9004, UINT16_MAX, 9004, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9006, UINT16_MAX, 9006, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9008, UINT16_MAX, 9008, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9010, UINT16_MAX, 9010, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9012, UINT16_MAX, 9012, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9014, UINT16_MAX, 9014, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9016, UINT16_MAX, 9016, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9018, UINT16_MAX, 9018, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9020, UINT16_MAX, 9020, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9022, UINT16_MAX, 9022, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9024, UINT16_MAX, 9024, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9026, UINT16_MAX, 9026, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9028, UINT16_MAX, 9028, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9030, UINT16_MAX, 9030, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9032, UINT16_MAX, 9032, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9034, UINT16_MAX, 9034, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9036, UINT16_MAX, 9036, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9038, UINT16_MAX, 9038, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9040, UINT16_MAX, 9040, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9042, UINT16_MAX, 9042, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9044, UINT16_MAX, 9044, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9046, UINT16_MAX, 9046, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9048, UINT16_MAX, 9048, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9050, UINT16_MAX, 9050, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9052, UINT16_MAX, 9052, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9054, UINT16_MAX, 9054, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9056, UINT16_MAX, 9056, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9058, UINT16_MAX, 9058, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9060, UINT16_MAX, 9060, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9062, UINT16_MAX, 9062, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9064, UINT16_MAX, 9064, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9066, UINT16_MAX, 9066, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9068, UINT16_MAX, 9068, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9070, UINT16_MAX, 9070, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9072, UINT16_MAX, 9072, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9074, UINT16_MAX, 9074, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9076, UINT16_MAX, 9076, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9078, UINT16_MAX, 9078, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9080, UINT16_MAX, 9080, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9082, UINT16_MAX, 9082, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9084, UINT16_MAX, 9084, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9086, UINT16_MAX, 9086, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9088, UINT16_MAX, 9088, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9090, UINT16_MAX, 9090, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9092, UINT16_MAX, 9092, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9094, UINT16_MAX, 9094, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 9096, UINT16_MAX, 9096, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9098, UINT16_MAX, 9098, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9100, UINT16_MAX, 9100, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9102, UINT16_MAX, 9102, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9104, UINT16_MAX, 9104, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9106, UINT16_MAX, 9106, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9108, UINT16_MAX, 9108, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9110, UINT16_MAX, 9110, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9112, UINT16_MAX, 9112, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9114, UINT16_MAX, 9114, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9116, UINT16_MAX, 9116, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9118, UINT16_MAX, 9118, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9120, UINT16_MAX, 9120, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9122, UINT16_MAX, 9122, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9124, UINT16_MAX, 9124, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9126, UINT16_MAX, 9126, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9128, UINT16_MAX, 9128, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9130, UINT16_MAX, 9130, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9132, UINT16_MAX, 9132, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9134, UINT16_MAX, 9134, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9136, UINT16_MAX, 9136, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9138, UINT16_MAX, 9138, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9140, UINT16_MAX, 9140, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9142, UINT16_MAX, 9142, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9144, UINT16_MAX, 9144, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9146, UINT16_MAX, 9146, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9148, UINT16_MAX, 9148, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9150, UINT16_MAX, 9150, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9152, UINT16_MAX, 9152, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9154, UINT16_MAX, 9154, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9156, UINT16_MAX, 9156, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9158, UINT16_MAX, 9158, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9160, UINT16_MAX, 9160, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9162, UINT16_MAX, 9162, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9164, UINT16_MAX, 9164, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9166, UINT16_MAX, 9166, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9168, UINT16_MAX, 9168, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9170, UINT16_MAX, 9170, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9172, UINT16_MAX, 9172, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9174, UINT16_MAX, 9174, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9176, UINT16_MAX, 9176, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9178, UINT16_MAX, 9178, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9180, UINT16_MAX, 9180, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9182, UINT16_MAX, 9182, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9184, UINT16_MAX, 9184, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9186, UINT16_MAX, 9186, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9188, UINT16_MAX, 9188, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9190, UINT16_MAX, 9190, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9192, UINT16_MAX, 9192, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9194, UINT16_MAX, 9194, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9196, UINT16_MAX, 9196, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9198, UINT16_MAX, 9198, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_AN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5328, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25584, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5332, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25588, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5336, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25592, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 7, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49206, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_PREPEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49208, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 25596, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 25600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5340, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5344, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49210, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5348, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 25604, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 25608, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49212, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49216, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5354, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49214, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 25612, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 25616, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49218, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 25620, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49220, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5362, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5366, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 25624, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 25628, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9248, UINT16_MAX, 9248, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9250, UINT16_MAX, 9250, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9252, UINT16_MAX, 9252, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9254, UINT16_MAX, 9254, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9256, UINT16_MAX, 9256, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9258, UINT16_MAX, 9258, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9260, UINT16_MAX, 9260, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9262, UINT16_MAX, 9262, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9264, UINT16_MAX, 9264, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9266, UINT16_MAX, 9266, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9268, UINT16_MAX, 9268, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9270, UINT16_MAX, 9270, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9272, UINT16_MAX, 9272, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9274, UINT16_MAX, 9274, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9276, UINT16_MAX, 9276, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9278, UINT16_MAX, 9278, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9280, UINT16_MAX, 9280, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9282, UINT16_MAX, 9282, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9284, UINT16_MAX, 9284, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9286, UINT16_MAX, 9286, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9288, UINT16_MAX, 9288, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9290, UINT16_MAX, 9290, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9292, UINT16_MAX, 9292, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9294, UINT16_MAX, 9294, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9296, UINT16_MAX, 9296, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9298, UINT16_MAX, 9298, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9300, UINT16_MAX, 9300, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9302, UINT16_MAX, 9302, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9304, UINT16_MAX, 9304, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9306, UINT16_MAX, 9306, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9308, UINT16_MAX, 9308, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9310, UINT16_MAX, 9310, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9312, UINT16_MAX, 9312, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9314, UINT16_MAX, 9314, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9316, UINT16_MAX, 9316, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9318, UINT16_MAX, 9318, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9320, UINT16_MAX, 9320, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9322, UINT16_MAX, 9322, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9324, UINT16_MAX, 9324, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9326, UINT16_MAX, 9326, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9328, UINT16_MAX, 9328, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9330, UINT16_MAX, 9330, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9332, UINT16_MAX, 9332, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9334, UINT16_MAX, 9334, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9336, UINT16_MAX, 9336, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9338, UINT16_MAX, 9338, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9340, UINT16_MAX, 9340, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9342, UINT16_MAX, 9342, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9344, UINT16_MAX, 9344, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9346, UINT16_MAX, 9346, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9348, UINT16_MAX, 9348, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9350, UINT16_MAX, 9350, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9352, UINT16_MAX, 9352, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9354, UINT16_MAX, 9354, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9356, UINT16_MAX, 9356, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9358, UINT16_MAX, 9358, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9360, UINT16_MAX, 9360, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9362, UINT16_MAX, 9362, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9364, UINT16_MAX, 9364, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9366, UINT16_MAX, 9366, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9368, UINT16_MAX, 9368, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9370, UINT16_MAX, 9370, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9372, UINT16_MAX, 9372, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9374, UINT16_MAX, 9374, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49222, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5370, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 25760, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MN, 9, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9380, UINT16_MAX, 9380, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9382, UINT16_MAX, 9382, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9384, UINT16_MAX, 9384, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9386, UINT16_MAX, 9386, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9388, UINT16_MAX, 9388, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9390, UINT16_MAX, 9390, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9392, UINT16_MAX, 9392, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9394, UINT16_MAX, 9394, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9396, UINT16_MAX, 9396, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9398, UINT16_MAX, 9398, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9400, UINT16_MAX, 9400, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9402, UINT16_MAX, 9402, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9404, UINT16_MAX, 9404, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9406, UINT16_MAX, 9406, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9408, UINT16_MAX, 9408, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9410, UINT16_MAX, 9410, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9412, UINT16_MAX, 9412, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9414, UINT16_MAX, 9414, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9416, UINT16_MAX, 9416, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9418, UINT16_MAX, 9418, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9420, UINT16_MAX, 9420, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9422, UINT16_MAX, 9422, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9424, UINT16_MAX, 9424, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9426, UINT16_MAX, 9426, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9428, UINT16_MAX, 9428, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9430, UINT16_MAX, 9430, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9432, UINT16_MAX, 9432, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9434, UINT16_MAX, 9434, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9436, UINT16_MAX, 9436, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9438, UINT16_MAX, 9438, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9440, UINT16_MAX, 9440, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9442, UINT16_MAX, 9442, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9444, UINT16_MAX, 9444, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9446, UINT16_MAX, 9446, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9448, UINT16_MAX, 9448, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9450, UINT16_MAX, 9450, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9452, UINT16_MAX, 9452, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9454, UINT16_MAX, 9454, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9456, UINT16_MAX, 9456, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9458, UINT16_MAX, 9458, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9460, UINT16_MAX, 9460, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9462, UINT16_MAX, 9462, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9464, UINT16_MAX, 9464, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9466, UINT16_MAX, 9466, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9468, UINT16_MAX, 9468, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9470, UINT16_MAX, 9470, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9472, UINT16_MAX, 9472, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9474, UINT16_MAX, 9474, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9476, UINT16_MAX, 9476, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9478, UINT16_MAX, 9478, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9480, UINT16_MAX, 9480, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9482, UINT16_MAX, 9482, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9484, UINT16_MAX, 9484, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9486, UINT16_MAX, 9486, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9488, UINT16_MAX, 9488, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9490, UINT16_MAX, 9490, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9492, UINT16_MAX, 9492, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9494, UINT16_MAX, 9494, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9496, UINT16_MAX, 9496, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9498, UINT16_MAX, 9498, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9500, UINT16_MAX, 9500, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9502, UINT16_MAX, 9502, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9504, UINT16_MAX, 9504, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9506, UINT16_MAX, 9506, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 6, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5374, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5378, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25892, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25896, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5382, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25900, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25904, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25908, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25912, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25916, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 216, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49224, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MC, 216, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 226, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_MC, 216, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49226, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MC, 216, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49228, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MC, 216, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49230, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MC, 216, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49232, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_MC, 216, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49234, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_EXTEND}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5394, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5398, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25920, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5402, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25924, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5408, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25928, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25932, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25936, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 25940, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 26, UINT16_MAX, UINT16_MAX, 9560, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 27, UINT16_MAX, UINT16_MAX, 9562, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 28, UINT16_MAX, UINT16_MAX, 9564, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 29, UINT16_MAX, UINT16_MAX, 9566, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 30, UINT16_MAX, UINT16_MAX, 9568, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 31, UINT16_MAX, UINT16_MAX, 9570, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 32, UINT16_MAX, UINT16_MAX, 9572, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 33, UINT16_MAX, UINT16_MAX, 9574, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 34, UINT16_MAX, UINT16_MAX, 9576, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 35, UINT16_MAX, UINT16_MAX, 9578, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 36, UINT16_MAX, UINT16_MAX, 9580, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 37, UINT16_MAX, UINT16_MAX, 9582, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 38, UINT16_MAX, UINT16_MAX, 9584, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 39, UINT16_MAX, UINT16_MAX, 9586, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 40, UINT16_MAX, UINT16_MAX, 9588, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 41, UINT16_MAX, UINT16_MAX, 9590, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 42, UINT16_MAX, UINT16_MAX, 9592, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 43, UINT16_MAX, UINT16_MAX, 9594, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 44, UINT16_MAX, UINT16_MAX, 9596, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 45, UINT16_MAX, UINT16_MAX, 9598, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 46, UINT16_MAX, UINT16_MAX, 9600, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 47, UINT16_MAX, UINT16_MAX, 9602, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 48, UINT16_MAX, UINT16_MAX, 9604, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 49, UINT16_MAX, UINT16_MAX, 9606, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 50, UINT16_MAX, UINT16_MAX, 9608, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 51, UINT16_MAX, UINT16_MAX, 9610, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 0, UINT16_MAX, 9612, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1, UINT16_MAX, 9614, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2, UINT16_MAX, 9616, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3, UINT16_MAX, 9618, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 4, UINT16_MAX, 9620, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 5, UINT16_MAX, 9622, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 6, UINT16_MAX, 9624, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7, UINT16_MAX, 9626, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, 9628, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 9, UINT16_MAX, 9630, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10, UINT16_MAX, 9632, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 11, UINT16_MAX, 9634, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 12, UINT16_MAX, 9636, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 13, UINT16_MAX, 9638, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 14, UINT16_MAX, 9640, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 15, UINT16_MAX, 9642, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 16, UINT16_MAX, 9644, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 17, UINT16_MAX, 9646, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 18, UINT16_MAX, 9648, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 19, UINT16_MAX, 9650, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 20, UINT16_MAX, 9652, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 21, UINT16_MAX, 9654, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 22, UINT16_MAX, 9656, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 23, UINT16_MAX, 9658, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 24, UINT16_MAX, 9660, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 25, UINT16_MAX, 9662, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 26, UINT16_MAX, UINT16_MAX, 9664, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 27, UINT16_MAX, UINT16_MAX, 9666, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 28, UINT16_MAX, UINT16_MAX, 9668, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 29, UINT16_MAX, UINT16_MAX, 9670, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 30, UINT16_MAX, UINT16_MAX, 9672, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 31, UINT16_MAX, UINT16_MAX, 9674, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 32, UINT16_MAX, UINT16_MAX, 9676, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 33, UINT16_MAX, UINT16_MAX, 9678, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 34, UINT16_MAX, UINT16_MAX, 9680, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 35, UINT16_MAX, UINT16_MAX, 9682, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 36, UINT16_MAX, UINT16_MAX, 9684, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 37, UINT16_MAX, UINT16_MAX, 9686, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 38, UINT16_MAX, UINT16_MAX, 9688, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 39, UINT16_MAX, UINT16_MAX, 9690, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 40, UINT16_MAX, UINT16_MAX, 9692, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 41, UINT16_MAX, UINT16_MAX, 9694, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 42, UINT16_MAX, UINT16_MAX, 9696, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 43, UINT16_MAX, UINT16_MAX, 9698, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 44, UINT16_MAX, UINT16_MAX, 9700, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 45, UINT16_MAX, UINT16_MAX, 9702, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 46, UINT16_MAX, UINT16_MAX, 9704, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 47, UINT16_MAX, UINT16_MAX, 9706, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 48, UINT16_MAX, UINT16_MAX, 9708, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 49, UINT16_MAX, UINT16_MAX, 9710, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 50, UINT16_MAX, UINT16_MAX, 9712, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 51, UINT16_MAX, UINT16_MAX, 9714, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 0, UINT16_MAX, 9716, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1, UINT16_MAX, 9718, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2, UINT16_MAX, 9720, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3, UINT16_MAX, 9722, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 4, UINT16_MAX, 9724, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 5, UINT16_MAX, 9726, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 6, UINT16_MAX, 9728, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, 9730, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 9, UINT16_MAX, 9732, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10, UINT16_MAX, 9734, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 11, UINT16_MAX, 9736, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 12, UINT16_MAX, 9738, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 13, UINT16_MAX, 9740, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 14, UINT16_MAX, 9742, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 15, UINT16_MAX, 9744, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 16, UINT16_MAX, 9746, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 17, UINT16_MAX, 9748, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 18, UINT16_MAX, 9750, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 19, UINT16_MAX, 9752, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 20, UINT16_MAX, 9754, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 21, UINT16_MAX, 9756, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 22, UINT16_MAX, 9758, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 23, UINT16_MAX, 9760, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 24, UINT16_MAX, 9762, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 25, UINT16_MAX, 9764, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 26, UINT16_MAX, UINT16_MAX, 9766, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 27, UINT16_MAX, UINT16_MAX, 9768, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 28, UINT16_MAX, UINT16_MAX, 9770, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 29, UINT16_MAX, UINT16_MAX, 9772, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 30, UINT16_MAX, UINT16_MAX, 9774, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 31, UINT16_MAX, UINT16_MAX, 9776, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 32, UINT16_MAX, UINT16_MAX, 9778, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 33, UINT16_MAX, UINT16_MAX, 9780, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 34, UINT16_MAX, UINT16_MAX, 9782, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 35, UINT16_MAX, UINT16_MAX, 9784, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 36, UINT16_MAX, UINT16_MAX, 9786, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 37, UINT16_MAX, UINT16_MAX, 9788, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 38, UINT16_MAX, UINT16_MAX, 9790, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 39, UINT16_MAX, UINT16_MAX, 9792, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 40, UINT16_MAX, UINT16_MAX, 9794, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 41, UINT16_MAX, UINT16_MAX, 9796, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 42, UINT16_MAX, UINT16_MAX, 9798, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 43, UINT16_MAX, UINT16_MAX, 9800, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 44, UINT16_MAX, UINT16_MAX, 9802, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 45, UINT16_MAX, UINT16_MAX, 9804, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 46, UINT16_MAX, UINT16_MAX, 9806, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 47, UINT16_MAX, UINT16_MAX, 9808, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 48, UINT16_MAX, UINT16_MAX, 9810, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 49, UINT16_MAX, UINT16_MAX, 9812, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 50, UINT16_MAX, UINT16_MAX, 9814, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 51, UINT16_MAX, UINT16_MAX, 9816, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 0, UINT16_MAX, 9818, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1, UINT16_MAX, 9820, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2, UINT16_MAX, 9822, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3, UINT16_MAX, 9824, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 4, UINT16_MAX, 9826, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 5, UINT16_MAX, 9828, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 6, UINT16_MAX, 9830, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7, UINT16_MAX, 9832, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, 9834, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 9, UINT16_MAX, 9836, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10, UINT16_MAX, 9838, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 11, UINT16_MAX, 9840, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 12, UINT16_MAX, 9842, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 13, UINT16_MAX, 9844, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 14, UINT16_MAX, 9846, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 15, UINT16_MAX, 9848, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 16, UINT16_MAX, 9850, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 17, UINT16_MAX, 9852, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 18, UINT16_MAX, 9854, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 19, UINT16_MAX, 9856, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 20, UINT16_MAX, 9858, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 21, UINT16_MAX, 9860, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 22, UINT16_MAX, 9862, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 23, UINT16_MAX, 9864, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 24, UINT16_MAX, 9866, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 25, UINT16_MAX, 9868, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 26, UINT16_MAX, UINT16_MAX, 9870, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 28, UINT16_MAX, UINT16_MAX, 9872, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 29, UINT16_MAX, UINT16_MAX, 9874, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 32, UINT16_MAX, UINT16_MAX, 9876, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 35, UINT16_MAX, UINT16_MAX, 9878, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 36, UINT16_MAX, UINT16_MAX, 9880, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 39, UINT16_MAX, UINT16_MAX, 9882, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 40, UINT16_MAX, UINT16_MAX, 9884, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 41, UINT16_MAX, UINT16_MAX, 9886, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 42, UINT16_MAX, UINT16_MAX, 9888, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 44, UINT16_MAX, UINT16_MAX, 9890, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 45, UINT16_MAX, UINT16_MAX, 9892, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 46, UINT16_MAX, UINT16_MAX, 9894, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 47, UINT16_MAX, UINT16_MAX, 9896, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 48, UINT16_MAX, UINT16_MAX, 9898, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 49, UINT16_MAX, UINT16_MAX, 9900, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 50, UINT16_MAX, UINT16_MAX, 9902, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 51, UINT16_MAX, UINT16_MAX, 9904, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 0, UINT16_MAX, 9906, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1, UINT16_MAX, 9908, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2, UINT16_MAX, 9910, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3, UINT16_MAX, 9912, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 5, UINT16_MAX, 9914, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7, UINT16_MAX, 9916, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, 9918, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 9, UINT16_MAX, 9920, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10, UINT16_MAX, 9922, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 11, UINT16_MAX, 9924, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 12, UINT16_MAX, 9926, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 13, UINT16_MAX, 9928, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 15, UINT16_MAX, 9930, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 16, UINT16_MAX, 9932, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 17, UINT16_MAX, 9934, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 18, UINT16_MAX, 9936, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 19, UINT16_MAX, 9938, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 20, UINT16_MAX, 9940, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 21, UINT16_MAX, 9942, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 22, UINT16_MAX, 9944, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 23, UINT16_MAX, 9946, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 24, UINT16_MAX, 9948, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 25, UINT16_MAX, 9950, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 26, UINT16_MAX, UINT16_MAX, 9952, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 27, UINT16_MAX, UINT16_MAX, 9954, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 28, UINT16_MAX, UINT16_MAX, 9956, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 29, UINT16_MAX, UINT16_MAX, 9958, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 30, UINT16_MAX, UINT16_MAX, 9960, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 31, UINT16_MAX, UINT16_MAX, 9962, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 32, UINT16_MAX, UINT16_MAX, 9964, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 33, UINT16_MAX, UINT16_MAX, 9966, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 34, UINT16_MAX, UINT16_MAX, 9968, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 35, UINT16_MAX, UINT16_MAX, 9970, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 36, UINT16_MAX, UINT16_MAX, 9972, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 37, UINT16_MAX, UINT16_MAX, 9974, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 38, UINT16_MAX, UINT16_MAX, 9976, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 39, UINT16_MAX, UINT16_MAX, 9978, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 40, UINT16_MAX, UINT16_MAX, 9980, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 41, UINT16_MAX, UINT16_MAX, 9982, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 42, UINT16_MAX, UINT16_MAX, 9984, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 43, UINT16_MAX, UINT16_MAX, 9986, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 44, UINT16_MAX, UINT16_MAX, 9988, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 45, UINT16_MAX, UINT16_MAX, 9990, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 46, UINT16_MAX, UINT16_MAX, 9992, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 47, UINT16_MAX, UINT16_MAX, 9994, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 48, UINT16_MAX, UINT16_MAX, 9996, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 49, UINT16_MAX, UINT16_MAX, 9998, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 50, UINT16_MAX, UINT16_MAX, 10000, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 51, UINT16_MAX, UINT16_MAX, 10002, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 0, UINT16_MAX, 10004, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1, UINT16_MAX, 10006, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2, UINT16_MAX, 10008, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3, UINT16_MAX, 10010, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 4, UINT16_MAX, 10012, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 5, UINT16_MAX, 10014, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 6, UINT16_MAX, 10016, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7, UINT16_MAX, 10018, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, 10020, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 9, UINT16_MAX, 10022, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10, UINT16_MAX, 10024, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 11, UINT16_MAX, 10026, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 12, UINT16_MAX, 10028, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 13, UINT16_MAX, 10030, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 14, UINT16_MAX, 10032, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 15, UINT16_MAX, 10034, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 16, UINT16_MAX, 10036, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 17, UINT16_MAX, 10038, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 18, UINT16_MAX, 10040, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 19, UINT16_MAX, 10042, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 20, UINT16_MAX, 10044, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 21, UINT16_MAX, 10046, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 22, UINT16_MAX, 10048, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 23, UINT16_MAX, 10050, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 24, UINT16_MAX, 10052, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 25, UINT16_MAX, 10054, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 26, UINT16_MAX, UINT16_MAX, 10056, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 27, UINT16_MAX, UINT16_MAX, 10058, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 29, UINT16_MAX, UINT16_MAX, 10060, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 30, UINT16_MAX, UINT16_MAX, 10062, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 31, UINT16_MAX, UINT16_MAX, 10064, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 32, UINT16_MAX, UINT16_MAX, 10066, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 35, UINT16_MAX, UINT16_MAX, 10068, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 36, UINT16_MAX, UINT16_MAX, 10070, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 37, UINT16_MAX, UINT16_MAX, 10072, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 38, UINT16_MAX, UINT16_MAX, 10074, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 39, UINT16_MAX, UINT16_MAX, 10076, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 40, UINT16_MAX, UINT16_MAX, 10078, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 41, UINT16_MAX, UINT16_MAX, 10080, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 42, UINT16_MAX, UINT16_MAX, 10082, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 44, UINT16_MAX, UINT16_MAX, 10084, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 45, UINT16_MAX, UINT16_MAX, 10086, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 46, UINT16_MAX, UINT16_MAX, 10088, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 47, UINT16_MAX, UINT16_MAX, 10090, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 48, UINT16_MAX, UINT16_MAX, 10092, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 49, UINT16_MAX, UINT16_MAX, 10094, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 50, UINT16_MAX, UINT16_MAX, 10096, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 0, UINT16_MAX, 10098, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1, UINT16_MAX, 10100, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2, UINT16_MAX, 10102, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3, UINT16_MAX, 10104, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 4, UINT16_MAX, 10106, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 5, UINT16_MAX, 10108, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 6, UINT16_MAX, 10110, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7, UINT16_MAX, 10112, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, 10114, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 9, UINT16_MAX, 10116, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10, UINT16_MAX, 10118, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 11, UINT16_MAX, 10120, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 12, UINT16_MAX, 10122, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 13, UINT16_MAX, 10124, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 14, UINT16_MAX, 10126, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 15, UINT16_MAX, 10128, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 16, UINT16_MAX, 10130, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 17, UINT16_MAX, 10132, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 18, UINT16_MAX, 10134, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 19, UINT16_MAX, 10136, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 20, UINT16_MAX, 10138, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 21, UINT16_MAX, 10140, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 22, UINT16_MAX, 10142, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 23, UINT16_MAX, 10144, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 24, UINT16_MAX, 10146, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 25, UINT16_MAX, 10148, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 26, UINT16_MAX, UINT16_MAX, 10150, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 27, UINT16_MAX, UINT16_MAX, 10152, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 29, UINT16_MAX, UINT16_MAX, 10154, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 30, UINT16_MAX, UINT16_MAX, 10156, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 31, UINT16_MAX, UINT16_MAX, 10158, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 32, UINT16_MAX, UINT16_MAX, 10160, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 34, UINT16_MAX, UINT16_MAX, 10162, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 35, UINT16_MAX, UINT16_MAX, 10164, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 36, UINT16_MAX, UINT16_MAX, 10166, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 37, UINT16_MAX, UINT16_MAX, 10168, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 38, UINT16_MAX, UINT16_MAX, 10170, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 40, UINT16_MAX, UINT16_MAX, 10172, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 44, UINT16_MAX, UINT16_MAX, 10174, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 45, UINT16_MAX, UINT16_MAX, 10176, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 46, UINT16_MAX, UINT16_MAX, 10178, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 47, UINT16_MAX, UINT16_MAX, 10180, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 48, UINT16_MAX, UINT16_MAX, 10182, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 49, UINT16_MAX, UINT16_MAX, 10184, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 50, UINT16_MAX, UINT16_MAX, 10186, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 0, UINT16_MAX, 10188, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1, UINT16_MAX, 10190, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2, UINT16_MAX, 10192, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3, UINT16_MAX, 10194, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 4, UINT16_MAX, 10196, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 5, UINT16_MAX, 10198, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 6, UINT16_MAX, 10200, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7, UINT16_MAX, 10202, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, 10204, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 9, UINT16_MAX, 10206, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10, UINT16_MAX, 10208, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 11, UINT16_MAX, 10210, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 12, UINT16_MAX, 10212, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 13, UINT16_MAX, 10214, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 14, UINT16_MAX, 10216, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 15, UINT16_MAX, 10218, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 16, UINT16_MAX, 10220, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 17, UINT16_MAX, 10222, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 18, UINT16_MAX, 10224, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 19, UINT16_MAX, 10226, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 20, UINT16_MAX, 10228, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 21, UINT16_MAX, 10230, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 22, UINT16_MAX, 10232, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 23, UINT16_MAX, 10234, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 24, UINT16_MAX, 10236, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 25, UINT16_MAX, 10238, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 26, UINT16_MAX, UINT16_MAX, 10240, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 27, UINT16_MAX, UINT16_MAX, 10242, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 28, UINT16_MAX, UINT16_MAX, 10244, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 29, UINT16_MAX, UINT16_MAX, 10246, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 30, UINT16_MAX, UINT16_MAX, 10248, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 31, UINT16_MAX, UINT16_MAX, 10250, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 32, UINT16_MAX, UINT16_MAX, 10252, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 33, UINT16_MAX, UINT16_MAX, 10254, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 34, UINT16_MAX, UINT16_MAX, 10256, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 35, UINT16_MAX, UINT16_MAX, 10258, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 36, UINT16_MAX, UINT16_MAX, 10260, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 37, UINT16_MAX, UINT16_MAX, 10262, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 38, UINT16_MAX, UINT16_MAX, 10264, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 39, UINT16_MAX, UINT16_MAX, 10266, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 40, UINT16_MAX, UINT16_MAX, 10268, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 41, UINT16_MAX, UINT16_MAX, 10270, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 42, UINT16_MAX, UINT16_MAX, 10272, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 43, UINT16_MAX, UINT16_MAX, 10274, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 44, UINT16_MAX, UINT16_MAX, 10276, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 45, UINT16_MAX, UINT16_MAX, 10278, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 46, UINT16_MAX, UINT16_MAX, 10280, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 47, UINT16_MAX, UINT16_MAX, 10282, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 48, UINT16_MAX, UINT16_MAX, 10284, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 49, UINT16_MAX, UINT16_MAX, 10286, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 50, UINT16_MAX, UINT16_MAX, 10288, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 51, UINT16_MAX, UINT16_MAX, 10290, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 0, UINT16_MAX, 10292, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1, UINT16_MAX, 10294, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2, UINT16_MAX, 10296, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3, UINT16_MAX, 10298, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 4, UINT16_MAX, 10300, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 5, UINT16_MAX, 10302, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 6, UINT16_MAX, 10304, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7, UINT16_MAX, 10306, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, 10308, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 9, UINT16_MAX, 10310, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10, UINT16_MAX, 10312, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 11, UINT16_MAX, 10314, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 12, UINT16_MAX, 10316, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 13, UINT16_MAX, 10318, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 14, UINT16_MAX, 10320, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 15, UINT16_MAX, 10322, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 16, UINT16_MAX, 10324, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 17, UINT16_MAX, 10326, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 18, UINT16_MAX, 10328, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 19, UINT16_MAX, 10330, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 20, UINT16_MAX, 10332, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 21, UINT16_MAX, 10334, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 22, UINT16_MAX, 10336, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 23, UINT16_MAX, 10338, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 24, UINT16_MAX, 10340, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 25, UINT16_MAX, 10342, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 26, UINT16_MAX, UINT16_MAX, 10344, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 27, UINT16_MAX, UINT16_MAX, 10346, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 28, UINT16_MAX, UINT16_MAX, 10348, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 29, UINT16_MAX, UINT16_MAX, 10350, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 30, UINT16_MAX, UINT16_MAX, 10352, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 31, UINT16_MAX, UINT16_MAX, 10354, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 32, UINT16_MAX, UINT16_MAX, 10356, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 33, UINT16_MAX, UINT16_MAX, 10358, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 34, UINT16_MAX, UINT16_MAX, 10360, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 35, UINT16_MAX, UINT16_MAX, 10362, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 36, UINT16_MAX, UINT16_MAX, 10364, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 37, UINT16_MAX, UINT16_MAX, 10366, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 38, UINT16_MAX, UINT16_MAX, 10368, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 39, UINT16_MAX, UINT16_MAX, 10370, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 40, UINT16_MAX, UINT16_MAX, 10372, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 41, UINT16_MAX, UINT16_MAX, 10374, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 42, UINT16_MAX, UINT16_MAX, 10376, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 43, UINT16_MAX, UINT16_MAX, 10378, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 44, UINT16_MAX, UINT16_MAX, 10380, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 45, UINT16_MAX, UINT16_MAX, 10382, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 46, UINT16_MAX, UINT16_MAX, 10384, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 47, UINT16_MAX, UINT16_MAX, 10386, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 48, UINT16_MAX, UINT16_MAX, 10388, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 49, UINT16_MAX, UINT16_MAX, 10390, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 50, UINT16_MAX, UINT16_MAX, 10392, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 51, UINT16_MAX, UINT16_MAX, 10394, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 0, UINT16_MAX, 10396, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1, UINT16_MAX, 10398, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2, UINT16_MAX, 10400, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3, UINT16_MAX, 10402, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 4, UINT16_MAX, 10404, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 5, UINT16_MAX, 10406, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 6, UINT16_MAX, 10408, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7, UINT16_MAX, 10410, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, 10412, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 9, UINT16_MAX, 10414, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10, UINT16_MAX, 10416, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 11, UINT16_MAX, 10418, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 12, UINT16_MAX, 10420, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 13, UINT16_MAX, 10422, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 14, UINT16_MAX, 10424, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 15, UINT16_MAX, 10426, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 16, UINT16_MAX, 10428, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 17, UINT16_MAX, 10430, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 18, UINT16_MAX, 10432, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 19, UINT16_MAX, 10434, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 20, UINT16_MAX, 10436, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 21, UINT16_MAX, 10438, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 22, UINT16_MAX, 10440, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 23, UINT16_MAX, 10442, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 24, UINT16_MAX, 10444, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 25, UINT16_MAX, 10446, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 26, UINT16_MAX, UINT16_MAX, 10448, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 27, UINT16_MAX, UINT16_MAX, 10450, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 28, UINT16_MAX, UINT16_MAX, 10452, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 29, UINT16_MAX, UINT16_MAX, 10454, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 30, UINT16_MAX, UINT16_MAX, 10456, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 31, UINT16_MAX, UINT16_MAX, 10458, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 32, UINT16_MAX, UINT16_MAX, 10460, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 33, UINT16_MAX, UINT16_MAX, 10462, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 34, UINT16_MAX, UINT16_MAX, 10464, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 35, UINT16_MAX, UINT16_MAX, 10466, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 36, UINT16_MAX, UINT16_MAX, 10468, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 37, UINT16_MAX, UINT16_MAX, 10470, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 38, UINT16_MAX, UINT16_MAX, 10472, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 39, UINT16_MAX, UINT16_MAX, 10474, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 40, UINT16_MAX, UINT16_MAX, 10476, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 41, UINT16_MAX, UINT16_MAX, 10478, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 42, UINT16_MAX, UINT16_MAX, 10480, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 43, UINT16_MAX, UINT16_MAX, 10482, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 44, UINT16_MAX, UINT16_MAX, 10484, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 45, UINT16_MAX, UINT16_MAX, 10486, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 46, UINT16_MAX, UINT16_MAX, 10488, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 47, UINT16_MAX, UINT16_MAX, 10490, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 48, UINT16_MAX, UINT16_MAX, 10492, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 49, UINT16_MAX, UINT16_MAX, 10494, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 50, UINT16_MAX, UINT16_MAX, 10496, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 51, UINT16_MAX, UINT16_MAX, 10498, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 0, UINT16_MAX, 10500, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1, UINT16_MAX, 10502, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2, UINT16_MAX, 10504, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3, UINT16_MAX, 10506, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 4, UINT16_MAX, 10508, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 5, UINT16_MAX, 10510, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 6, UINT16_MAX, 10512, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7, UINT16_MAX, 10514, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, 10516, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 9, UINT16_MAX, 10518, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10, UINT16_MAX, 10520, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 11, UINT16_MAX, 10522, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 12, UINT16_MAX, 10524, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 13, UINT16_MAX, 10526, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 14, UINT16_MAX, 10528, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 15, UINT16_MAX, 10530, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 16, UINT16_MAX, 10532, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 17, UINT16_MAX, 10534, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 18, UINT16_MAX, 10536, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 19, UINT16_MAX, 10538, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 20, UINT16_MAX, 10540, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 21, UINT16_MAX, 10542, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 22, UINT16_MAX, 10544, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 23, UINT16_MAX, 10546, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 24, UINT16_MAX, 10548, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 25, UINT16_MAX, 10550, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 26, UINT16_MAX, UINT16_MAX, 10552, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 27, UINT16_MAX, UINT16_MAX, 10554, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 28, UINT16_MAX, UINT16_MAX, 10556, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 29, UINT16_MAX, UINT16_MAX, 10558, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 30, UINT16_MAX, UINT16_MAX, 10560, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 31, UINT16_MAX, UINT16_MAX, 10562, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 32, UINT16_MAX, UINT16_MAX, 10564, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 33, UINT16_MAX, UINT16_MAX, 10566, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 34, UINT16_MAX, UINT16_MAX, 10568, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 35, UINT16_MAX, UINT16_MAX, 10570, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 36, UINT16_MAX, UINT16_MAX, 10572, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 37, UINT16_MAX, UINT16_MAX, 10574, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 38, UINT16_MAX, UINT16_MAX, 10576, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 39, UINT16_MAX, UINT16_MAX, 10578, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 40, UINT16_MAX, UINT16_MAX, 10580, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 41, UINT16_MAX, UINT16_MAX, 10582, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 42, UINT16_MAX, UINT16_MAX, 10584, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 43, UINT16_MAX, UINT16_MAX, 10586, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 44, UINT16_MAX, UINT16_MAX, 10588, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 45, UINT16_MAX, UINT16_MAX, 10590, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 46, UINT16_MAX, UINT16_MAX, 10592, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 47, UINT16_MAX, UINT16_MAX, 10594, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 48, UINT16_MAX, UINT16_MAX, 10596, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 49, UINT16_MAX, UINT16_MAX, 10598, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 50, UINT16_MAX, UINT16_MAX, 10600, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 51, UINT16_MAX, UINT16_MAX, 10602, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 0, UINT16_MAX, 10604, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1, UINT16_MAX, 10606, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2, UINT16_MAX, 10608, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3, UINT16_MAX, 10610, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 4, UINT16_MAX, 10612, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 5, UINT16_MAX, 10614, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 6, UINT16_MAX, 10616, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7, UINT16_MAX, 10618, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, 10620, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 9, UINT16_MAX, 10622, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10, UINT16_MAX, 10624, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 11, UINT16_MAX, 10626, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 12, UINT16_MAX, 10628, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 13, UINT16_MAX, 10630, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 14, UINT16_MAX, 10632, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 15, UINT16_MAX, 10634, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 16, UINT16_MAX, 10636, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 17, UINT16_MAX, 10638, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 18, UINT16_MAX, 10640, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 19, UINT16_MAX, 10642, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 20, UINT16_MAX, 10644, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 21, UINT16_MAX, 10646, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 22, UINT16_MAX, 10648, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 23, UINT16_MAX, 10650, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 24, UINT16_MAX, 10652, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 25, UINT16_MAX, 10654, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 26, UINT16_MAX, UINT16_MAX, 10656, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 27, UINT16_MAX, UINT16_MAX, 10658, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 28, UINT16_MAX, UINT16_MAX, 10660, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 29, UINT16_MAX, UINT16_MAX, 10662, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 30, UINT16_MAX, UINT16_MAX, 10664, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 31, UINT16_MAX, UINT16_MAX, 10666, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 32, UINT16_MAX, UINT16_MAX, 10668, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 33, UINT16_MAX, UINT16_MAX, 10670, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 34, UINT16_MAX, UINT16_MAX, 10672, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 35, UINT16_MAX, UINT16_MAX, 10674, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 36, UINT16_MAX, UINT16_MAX, 10676, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 37, UINT16_MAX, UINT16_MAX, 10678, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 38, UINT16_MAX, UINT16_MAX, 10680, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 39, UINT16_MAX, UINT16_MAX, 10682, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 40, UINT16_MAX, UINT16_MAX, 10684, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 41, UINT16_MAX, UINT16_MAX, 10686, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 42, UINT16_MAX, UINT16_MAX, 10688, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 43, UINT16_MAX, UINT16_MAX, 10690, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 44, UINT16_MAX, UINT16_MAX, 10692, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 45, UINT16_MAX, UINT16_MAX, 10694, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 46, UINT16_MAX, UINT16_MAX, 10696, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 47, UINT16_MAX, UINT16_MAX, 10698, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 48, UINT16_MAX, UINT16_MAX, 10700, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 49, UINT16_MAX, UINT16_MAX, 10702, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 50, UINT16_MAX, UINT16_MAX, 10704, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 51, UINT16_MAX, UINT16_MAX, 10706, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 0, UINT16_MAX, 10708, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1, UINT16_MAX, 10710, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2, UINT16_MAX, 10712, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3, UINT16_MAX, 10714, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 4, UINT16_MAX, 10716, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 5, UINT16_MAX, 10718, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 6, UINT16_MAX, 10720, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7, UINT16_MAX, 10722, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, 10724, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 9, UINT16_MAX, 10726, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10, UINT16_MAX, 10728, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 11, UINT16_MAX, 10730, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 12, UINT16_MAX, 10732, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 13, UINT16_MAX, 10734, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 14, UINT16_MAX, 10736, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 15, UINT16_MAX, 10738, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 16, UINT16_MAX, 10740, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 17, UINT16_MAX, 10742, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 18, UINT16_MAX, 10744, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 19, UINT16_MAX, 10746, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 20, UINT16_MAX, 10748, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 21, UINT16_MAX, 10750, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 22, UINT16_MAX, 10752, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 23, UINT16_MAX, 10754, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 24, UINT16_MAX, 10756, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 25, UINT16_MAX, 10758, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 26, UINT16_MAX, UINT16_MAX, 10760, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 27, UINT16_MAX, UINT16_MAX, 10762, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 28, UINT16_MAX, UINT16_MAX, 10764, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 29, UINT16_MAX, UINT16_MAX, 10766, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 30, UINT16_MAX, UINT16_MAX, 10768, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 31, UINT16_MAX, UINT16_MAX, 10770, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 32, UINT16_MAX, UINT16_MAX, 10772, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 33, UINT16_MAX, UINT16_MAX, 10774, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 34, UINT16_MAX, UINT16_MAX, 10776, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 35, UINT16_MAX, UINT16_MAX, 10778, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 36, UINT16_MAX, UINT16_MAX, 10780, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 37, UINT16_MAX, UINT16_MAX, 10782, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 38, UINT16_MAX, UINT16_MAX, 10784, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 39, UINT16_MAX, UINT16_MAX, 10786, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 40, UINT16_MAX, UINT16_MAX, 10788, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 41, UINT16_MAX, UINT16_MAX, 10790, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 42, UINT16_MAX, UINT16_MAX, 10792, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 43, UINT16_MAX, UINT16_MAX, 10794, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 44, UINT16_MAX, UINT16_MAX, 10796, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 45, UINT16_MAX, UINT16_MAX, 10798, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 46, UINT16_MAX, UINT16_MAX, 10800, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 47, UINT16_MAX, UINT16_MAX, 10802, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 48, UINT16_MAX, UINT16_MAX, 10804, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 49, UINT16_MAX, UINT16_MAX, 10806, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 50, UINT16_MAX, UINT16_MAX, 10808, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 51, UINT16_MAX, UINT16_MAX, 10810, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 0, UINT16_MAX, 10812, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1, UINT16_MAX, 10814, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2, UINT16_MAX, 10816, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3, UINT16_MAX, 10818, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 4, UINT16_MAX, 10820, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 5, UINT16_MAX, 10822, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 6, UINT16_MAX, 10824, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7, UINT16_MAX, 10826, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, 10828, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 9, UINT16_MAX, 10830, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10, UINT16_MAX, 10832, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 11, UINT16_MAX, 10834, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 12, UINT16_MAX, 10836, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 13, UINT16_MAX, 10838, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 14, UINT16_MAX, 10840, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 15, UINT16_MAX, 10842, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 16, UINT16_MAX, 10844, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 17, UINT16_MAX, 10846, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 18, UINT16_MAX, 10848, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 19, UINT16_MAX, 10850, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 20, UINT16_MAX, 10852, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 21, UINT16_MAX, 10854, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 22, UINT16_MAX, 10856, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 23, UINT16_MAX, 10858, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 24, UINT16_MAX, 10860, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 25, UINT16_MAX, 10862, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10864, UINT16_MAX, 10865, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 984, UINT16_MAX, 10867, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1231, UINT16_MAX, UINT16_MAX, 10869, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1232, UINT16_MAX, UINT16_MAX, 10871, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1233, UINT16_MAX, UINT16_MAX, 10873, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1234, UINT16_MAX, UINT16_MAX, 10875, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1235, UINT16_MAX, UINT16_MAX, 10877, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1236, UINT16_MAX, UINT16_MAX, 10879, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1237, UINT16_MAX, UINT16_MAX, 10881, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1238, UINT16_MAX, UINT16_MAX, 10883, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1139, UINT16_MAX, UINT16_MAX, 10885, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1239, UINT16_MAX, UINT16_MAX, 10887, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1240, UINT16_MAX, UINT16_MAX, 10889, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 63, UINT16_MAX, UINT16_MAX, 10891, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1241, UINT16_MAX, UINT16_MAX, 10893, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1242, UINT16_MAX, UINT16_MAX, 10895, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1243, UINT16_MAX, UINT16_MAX, 10897, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1244, UINT16_MAX, UINT16_MAX, 10899, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1245, UINT16_MAX, UINT16_MAX, 10901, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10903, UINT16_MAX, UINT16_MAX, 10904, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1246, UINT16_MAX, UINT16_MAX, 10906, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1247, UINT16_MAX, UINT16_MAX, 10908, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1248, UINT16_MAX, UINT16_MAX, 10910, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1249, UINT16_MAX, UINT16_MAX, 10912, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1250, UINT16_MAX, UINT16_MAX, 10914, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1251, UINT16_MAX, UINT16_MAX, 10916, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1252, UINT16_MAX, UINT16_MAX, 10918, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10920, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1185, UINT16_MAX, 10921, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1186, UINT16_MAX, 10923, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1187, UINT16_MAX, 10925, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1188, UINT16_MAX, 10927, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1189, UINT16_MAX, 10929, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1190, UINT16_MAX, 10931, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1191, UINT16_MAX, 10933, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1192, UINT16_MAX, 10935, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1138, UINT16_MAX, 10937, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1193, UINT16_MAX, 10939, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1194, UINT16_MAX, 10941, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 62, UINT16_MAX, 10943, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1195, UINT16_MAX, 10945, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1196, UINT16_MAX, 10947, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1197, UINT16_MAX, 10949, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1198, UINT16_MAX, 10951, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1199, UINT16_MAX, 10953, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1301, UINT16_MAX, 10955, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1200, UINT16_MAX, 10957, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1201, UINT16_MAX, 10959, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1202, UINT16_MAX, 10961, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1203, UINT16_MAX, 10963, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1204, UINT16_MAX, 10965, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1205, UINT16_MAX, 10967, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1206, UINT16_MAX, 10969, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FONT, 10971, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10972, UINT16_MAX, 10973, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10975, UINT16_MAX, 10976, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10978, UINT16_MAX, 10979, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10981, UINT16_MAX, 10982, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10984, UINT16_MAX, 10985, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10987, UINT16_MAX, 10988, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1231, UINT16_MAX, UINT16_MAX, 10990, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1232, UINT16_MAX, UINT16_MAX, 10992, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1233, UINT16_MAX, UINT16_MAX, 10994, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1234, UINT16_MAX, UINT16_MAX, 10996, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1235, UINT16_MAX, UINT16_MAX, 10998, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1236, UINT16_MAX, UINT16_MAX, 11000, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1237, UINT16_MAX, UINT16_MAX, 11002, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1238, UINT16_MAX, UINT16_MAX, 11004, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1139, UINT16_MAX, UINT16_MAX, 11006, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1239, UINT16_MAX, UINT16_MAX, 11008, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1240, UINT16_MAX, UINT16_MAX, 11010, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 63, UINT16_MAX, UINT16_MAX, 11012, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1241, UINT16_MAX, UINT16_MAX, 11014, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1242, UINT16_MAX, UINT16_MAX, 11016, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1243, UINT16_MAX, UINT16_MAX, 11018, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1244, UINT16_MAX, UINT16_MAX, 11020, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1245, UINT16_MAX, UINT16_MAX, 11022, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10903, UINT16_MAX, UINT16_MAX, 11024, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1246, UINT16_MAX, UINT16_MAX, 11026, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1247, UINT16_MAX, UINT16_MAX, 11028, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1248, UINT16_MAX, UINT16_MAX, 11030, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1249, UINT16_MAX, UINT16_MAX, 11032, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1250, UINT16_MAX, UINT16_MAX, 11034, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1251, UINT16_MAX, UINT16_MAX, 11036, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1252, UINT16_MAX, UINT16_MAX, 11038, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1185, UINT16_MAX, 11040, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1186, UINT16_MAX, 11042, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1187, UINT16_MAX, 11044, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1188, UINT16_MAX, 11046, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1189, UINT16_MAX, 11048, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1190, UINT16_MAX, 11050, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1191, UINT16_MAX, 11052, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1192, UINT16_MAX, 11054, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1138, UINT16_MAX, 11056, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1193, UINT16_MAX, 11058, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1194, UINT16_MAX, 11060, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 62, UINT16_MAX, 11062, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1195, UINT16_MAX, 11064, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1196, UINT16_MAX, 11066, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1197, UINT16_MAX, 11068, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1198, UINT16_MAX, 11070, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1199, UINT16_MAX, 11072, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1301, UINT16_MAX, 11074, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1200, UINT16_MAX, 11076, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1201, UINT16_MAX, 11078, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1202, UINT16_MAX, 11080, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1203, UINT16_MAX, 11082, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1204, UINT16_MAX, 11084, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1205, UINT16_MAX, 11086, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1206, UINT16_MAX, 11088, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10972, UINT16_MAX, 11090, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10975, UINT16_MAX, 11092, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10978, UINT16_MAX, 11094, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10981, UINT16_MAX, 11096, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10984, UINT16_MAX, 11098, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10987, UINT16_MAX, 11100, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1231, UINT16_MAX, UINT16_MAX, 11102, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1232, UINT16_MAX, UINT16_MAX, 11104, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1233, UINT16_MAX, UINT16_MAX, 11106, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1234, UINT16_MAX, UINT16_MAX, 11108, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1235, UINT16_MAX, UINT16_MAX, 11110, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1236, UINT16_MAX, UINT16_MAX, 11112, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1237, UINT16_MAX, UINT16_MAX, 11114, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1238, UINT16_MAX, UINT16_MAX, 11116, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1139, UINT16_MAX, UINT16_MAX, 11118, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1239, UINT16_MAX, UINT16_MAX, 11120, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1240, UINT16_MAX, UINT16_MAX, 11122, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 63, UINT16_MAX, UINT16_MAX, 11124, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1241, UINT16_MAX, UINT16_MAX, 11126, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1242, UINT16_MAX, UINT16_MAX, 11128, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1243, UINT16_MAX, UINT16_MAX, 11130, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1244, UINT16_MAX, UINT16_MAX, 11132, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1245, UINT16_MAX, UINT16_MAX, 11134, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10903, UINT16_MAX, UINT16_MAX, 11136, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1246, UINT16_MAX, UINT16_MAX, 11138, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1247, UINT16_MAX, UINT16_MAX, 11140, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1248, UINT16_MAX, UINT16_MAX, 11142, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1249, UINT16_MAX, UINT16_MAX, 11144, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1250, UINT16_MAX, UINT16_MAX, 11146, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1251, UINT16_MAX, UINT16_MAX, 11148, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1252, UINT16_MAX, UINT16_MAX, 11150, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1185, UINT16_MAX, 11152, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1186, UINT16_MAX, 11154, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1187, UINT16_MAX, 11156, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1188, UINT16_MAX, 11158, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1189, UINT16_MAX, 11160, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1190, UINT16_MAX, 11162, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1191, UINT16_MAX, 11164, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1192, UINT16_MAX, 11166, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1138, UINT16_MAX, 11168, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1193, UINT16_MAX, 11170, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1194, UINT16_MAX, 11172, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 62, UINT16_MAX, 11174, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1195, UINT16_MAX, 11176, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1196, UINT16_MAX, 11178, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1197, UINT16_MAX, 11180, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1198, UINT16_MAX, 11182, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1199, UINT16_MAX, 11184, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1301, UINT16_MAX, 11186, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1200, UINT16_MAX, 11188, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1201, UINT16_MAX, 11190, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1202, UINT16_MAX, 11192, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1203, UINT16_MAX, 11194, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1204, UINT16_MAX, 11196, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1205, UINT16_MAX, 11198, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1206, UINT16_MAX, 11200, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10972, UINT16_MAX, 11202, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10975, UINT16_MAX, 11204, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10978, UINT16_MAX, 11206, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10981, UINT16_MAX, 11208, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10984, UINT16_MAX, 11210, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10987, UINT16_MAX, 11212, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1231, UINT16_MAX, UINT16_MAX, 11214, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1232, UINT16_MAX, UINT16_MAX, 11216, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1233, UINT16_MAX, UINT16_MAX, 11218, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1234, UINT16_MAX, UINT16_MAX, 11220, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1235, UINT16_MAX, UINT16_MAX, 11222, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1236, UINT16_MAX, UINT16_MAX, 11224, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1237, UINT16_MAX, UINT16_MAX, 11226, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1238, UINT16_MAX, UINT16_MAX, 11228, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1139, UINT16_MAX, UINT16_MAX, 11230, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1239, UINT16_MAX, UINT16_MAX, 11232, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1240, UINT16_MAX, UINT16_MAX, 11234, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 63, UINT16_MAX, UINT16_MAX, 11236, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1241, UINT16_MAX, UINT16_MAX, 11238, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1242, UINT16_MAX, UINT16_MAX, 11240, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1243, UINT16_MAX, UINT16_MAX, 11242, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1244, UINT16_MAX, UINT16_MAX, 11244, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1245, UINT16_MAX, UINT16_MAX, 11246, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10903, UINT16_MAX, UINT16_MAX, 11248, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1246, UINT16_MAX, UINT16_MAX, 11250, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1247, UINT16_MAX, UINT16_MAX, 11252, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1248, UINT16_MAX, UINT16_MAX, 11254, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1249, UINT16_MAX, UINT16_MAX, 11256, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1250, UINT16_MAX, UINT16_MAX, 11258, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1251, UINT16_MAX, UINT16_MAX, 11260, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1252, UINT16_MAX, UINT16_MAX, 11262, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1185, UINT16_MAX, 11264, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1186, UINT16_MAX, 11266, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1187, UINT16_MAX, 11268, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1188, UINT16_MAX, 11270, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1189, UINT16_MAX, 11272, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1190, UINT16_MAX, 11274, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1191, UINT16_MAX, 11276, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1192, UINT16_MAX, 11278, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1138, UINT16_MAX, 11280, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1193, UINT16_MAX, 11282, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1194, UINT16_MAX, 11284, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 62, UINT16_MAX, 11286, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1195, UINT16_MAX, 11288, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1196, UINT16_MAX, 11290, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1197, UINT16_MAX, 11292, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1198, UINT16_MAX, 11294, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1199, UINT16_MAX, 11296, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1301, UINT16_MAX, 11298, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1200, UINT16_MAX, 11300, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1201, UINT16_MAX, 11302, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1202, UINT16_MAX, 11304, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1203, UINT16_MAX, 11306, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1204, UINT16_MAX, 11308, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1205, UINT16_MAX, 11310, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1206, UINT16_MAX, 11312, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10972, UINT16_MAX, 11314, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10975, UINT16_MAX, 11316, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10978, UINT16_MAX, 11318, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10981, UINT16_MAX, 11320, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10984, UINT16_MAX, 11322, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10987, UINT16_MAX, 11324, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1231, UINT16_MAX, UINT16_MAX, 11326, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1232, UINT16_MAX, UINT16_MAX, 11328, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1233, UINT16_MAX, UINT16_MAX, 11330, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1234, UINT16_MAX, UINT16_MAX, 11332, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1235, UINT16_MAX, UINT16_MAX, 11334, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1236, UINT16_MAX, UINT16_MAX, 11336, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1237, UINT16_MAX, UINT16_MAX, 11338, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1238, UINT16_MAX, UINT16_MAX, 11340, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1139, UINT16_MAX, UINT16_MAX, 11342, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1239, UINT16_MAX, UINT16_MAX, 11344, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1240, UINT16_MAX, UINT16_MAX, 11346, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 63, UINT16_MAX, UINT16_MAX, 11348, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1241, UINT16_MAX, UINT16_MAX, 11350, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1242, UINT16_MAX, UINT16_MAX, 11352, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1243, UINT16_MAX, UINT16_MAX, 11354, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1244, UINT16_MAX, UINT16_MAX, 11356, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1245, UINT16_MAX, UINT16_MAX, 11358, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10903, UINT16_MAX, UINT16_MAX, 11360, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1246, UINT16_MAX, UINT16_MAX, 11362, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1247, UINT16_MAX, UINT16_MAX, 11364, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1248, UINT16_MAX, UINT16_MAX, 11366, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1249, UINT16_MAX, UINT16_MAX, 11368, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1250, UINT16_MAX, UINT16_MAX, 11370, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1251, UINT16_MAX, UINT16_MAX, 11372, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1252, UINT16_MAX, UINT16_MAX, 11374, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1185, UINT16_MAX, 11376, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1186, UINT16_MAX, 11378, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1187, UINT16_MAX, 11380, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1188, UINT16_MAX, 11382, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1189, UINT16_MAX, 11384, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1190, UINT16_MAX, 11386, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1191, UINT16_MAX, 11388, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1192, UINT16_MAX, 11390, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1138, UINT16_MAX, 11392, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1193, UINT16_MAX, 11394, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1194, UINT16_MAX, 11396, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 62, UINT16_MAX, 11398, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1195, UINT16_MAX, 11400, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1196, UINT16_MAX, 11402, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1197, UINT16_MAX, 11404, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1198, UINT16_MAX, 11406, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1199, UINT16_MAX, 11408, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1301, UINT16_MAX, 11410, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1200, UINT16_MAX, 11412, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1201, UINT16_MAX, 11414, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1202, UINT16_MAX, 11416, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1203, UINT16_MAX, 11418, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1204, UINT16_MAX, 11420, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1205, UINT16_MAX, 11422, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1206, UINT16_MAX, 11424, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10972, UINT16_MAX, 11426, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10975, UINT16_MAX, 11428, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10978, UINT16_MAX, 11430, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10981, UINT16_MAX, 11432, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10984, UINT16_MAX, 11434, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10987, UINT16_MAX, 11436, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1282, UINT16_MAX, UINT16_MAX, 11438, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1281, UINT16_MAX, 11440, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 3929, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 66, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 58, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 59, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 3931, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 3932, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 3933, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 3934, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 3935, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 3936, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11442, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11444, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11446, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11448, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8921, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8929, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8935, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11450, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8949, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11452, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11454, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11456, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11458, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11460, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11462, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11464, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11466, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11468, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11470, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11472, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11474, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11476, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11478, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11480, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11482, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11484, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11486, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11488, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11490, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8992, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11492, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11494, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11496, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11498, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11500, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 11502, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1343, UINT16_MAX, 11504, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1344, UINT16_MAX, 11506, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1345, UINT16_MAX, 11508, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1346, UINT16_MAX, 11510, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1347, UINT16_MAX, 11512, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1348, UINT16_MAX, 11514, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1349, UINT16_MAX, 11516, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1350, UINT16_MAX, 11518, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1351, UINT16_MAX, 11520, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1355, UINT16_MAX, 11522, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1356, UINT16_MAX, 11524, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1357, UINT16_MAX, 11526, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1359, UINT16_MAX, 11528, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1360, UINT16_MAX, 11530, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1361, UINT16_MAX, 11532, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1362, UINT16_MAX, 11534, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1363, UINT16_MAX, 11536, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1364, UINT16_MAX, 11538, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1365, UINT16_MAX, 11540, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1366, UINT16_MAX, 11542, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1367, UINT16_MAX, 11544, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1368, UINT16_MAX, 11546, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1369, UINT16_MAX, 11548, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1372, UINT16_MAX, 11550, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1374, UINT16_MAX, 11552, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1375, UINT16_MAX, 11554, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 6566, UINT16_MAX, 11556, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1573, UINT16_MAX, 11558, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1325, UINT16_MAX, 11560, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1329, UINT16_MAX, 11562, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1613, UINT16_MAX, 11564, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1515, UINT16_MAX, 11566, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1533, UINT16_MAX, 11568, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1343, UINT16_MAX, 11570, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1344, UINT16_MAX, 11572, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1345, UINT16_MAX, 11574, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1346, UINT16_MAX, 11576, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1347, UINT16_MAX, 11578, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1348, UINT16_MAX, 11580, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1349, UINT16_MAX, 11582, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1350, UINT16_MAX, 11584, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1351, UINT16_MAX, 11586, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1355, UINT16_MAX, 11588, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1356, UINT16_MAX, 11590, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1359, UINT16_MAX, 11592, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1360, UINT16_MAX, 11594, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1362, UINT16_MAX, 11596, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1364, UINT16_MAX, 11598, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1365, UINT16_MAX, 11600, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1366, UINT16_MAX, 11602, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1367, UINT16_MAX, 11604, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1368, UINT16_MAX, 11606, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1369, UINT16_MAX, 11608, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1371, UINT16_MAX, 11610, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1372, UINT16_MAX, 11612, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1485, UINT16_MAX, 11614, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1325, UINT16_MAX, 11616, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1324, UINT16_MAX, 11618, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 1342, UINT16_MAX, 11620, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1511, UINT16_MAX, 11622, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 6528, UINT16_MAX, 11624, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1517, UINT16_MAX, 11626, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11628, UINT16_MAX, 11628, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11630, UINT16_MAX, 11630, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11632, UINT16_MAX, 11632, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11634, UINT16_MAX, 11634, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11636, UINT16_MAX, 11636, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11638, UINT16_MAX, 11638, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11640, UINT16_MAX, 11640, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11642, UINT16_MAX, 11642, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11644, UINT16_MAX, 11644, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11646, UINT16_MAX, 11646, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11648, UINT16_MAX, 11648, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11650, UINT16_MAX, 11650, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11652, UINT16_MAX, 11652, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11654, UINT16_MAX, 11654, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11656, UINT16_MAX, 11656, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11658, UINT16_MAX, 11658, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11660, UINT16_MAX, 11660, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11662, UINT16_MAX, 11662, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11664, UINT16_MAX, 11664, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11666, UINT16_MAX, 11666, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11668, UINT16_MAX, 11668, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11670, UINT16_MAX, 11670, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11672, UINT16_MAX, 11672, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11674, UINT16_MAX, 11674, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11676, UINT16_MAX, 11676, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11678, UINT16_MAX, 11678, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11680, UINT16_MAX, 11680, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11682, UINT16_MAX, 11682, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11684, UINT16_MAX, 11684, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11686, UINT16_MAX, 11686, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11688, UINT16_MAX, 11688, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11690, UINT16_MAX, 11690, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11692, UINT16_MAX, 11692, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 11694, UINT16_MAX, 11694, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11696, UINT16_MAX, 11696, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11698, UINT16_MAX, 11698, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11700, UINT16_MAX, 11700, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11702, UINT16_MAX, 11702, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11704, UINT16_MAX, 11704, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11706, UINT16_MAX, 11706, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11708, UINT16_MAX, 11708, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11710, UINT16_MAX, 11710, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11712, UINT16_MAX, 11712, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11714, UINT16_MAX, 11714, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11716, UINT16_MAX, 11716, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11718, UINT16_MAX, 11718, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11720, UINT16_MAX, 11720, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11722, UINT16_MAX, 11722, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11724, UINT16_MAX, 11724, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11726, UINT16_MAX, 11726, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11728, UINT16_MAX, 11728, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11730, UINT16_MAX, 11730, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11732, UINT16_MAX, 11732, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11734, UINT16_MAX, 11734, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11736, UINT16_MAX, 11736, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11738, UINT16_MAX, 11738, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11740, UINT16_MAX, 11740, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11742, UINT16_MAX, 11742, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11744, UINT16_MAX, 11744, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11746, UINT16_MAX, 11746, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11748, UINT16_MAX, 11748, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11750, UINT16_MAX, 11750, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11752, UINT16_MAX, 11752, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11754, UINT16_MAX, 11754, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11756, UINT16_MAX, 11756, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11758, UINT16_MAX, 11758, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11760, UINT16_MAX, 11760, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 11762, UINT16_MAX, 11762, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8248, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8249, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8253, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8256, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8275, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8259, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8254, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8264, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8270, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8271, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8272, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8273, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8260, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8266, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8268, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8262, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8269, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8258, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8261, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8251, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8252, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8255, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8257, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8263, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8265, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 11764, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 7450, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 11765, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 11766, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 8274, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 28151, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 28153, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 28155, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 28157, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 28159, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 28161, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 28163, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 28165, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 28167, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 28169, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 28171, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44557, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44560, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44563, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44566, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44569, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44572, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44575, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44578, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44581, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44584, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44587, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44590, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44593, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44596, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44599, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44602, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44605, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44608, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44611, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44614, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44617, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44620, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44623, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44626, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44629, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44632, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44635, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 28, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 43, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 28254, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 28256, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 26, UINT16_MAX, UINT16_MAX, 11874, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 27, UINT16_MAX, UINT16_MAX, 11876, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28, UINT16_MAX, UINT16_MAX, 11878, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29, UINT16_MAX, UINT16_MAX, 11880, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 30, UINT16_MAX, UINT16_MAX, 11882, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 31, UINT16_MAX, UINT16_MAX, 11884, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 32, UINT16_MAX, UINT16_MAX, 11886, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 33, UINT16_MAX, UINT16_MAX, 11888, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 34, UINT16_MAX, UINT16_MAX, 11890, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 35, UINT16_MAX, UINT16_MAX, 11892, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 36, UINT16_MAX, UINT16_MAX, 11894, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37, UINT16_MAX, UINT16_MAX, 11896, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 38, UINT16_MAX, UINT16_MAX, 11898, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 39, UINT16_MAX, UINT16_MAX, 11900, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 40, UINT16_MAX, UINT16_MAX, 11902, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 41, UINT16_MAX, UINT16_MAX, 11904, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 42, UINT16_MAX, UINT16_MAX, 11906, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 43, UINT16_MAX, UINT16_MAX, 11908, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 44, UINT16_MAX, UINT16_MAX, 11910, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 45, UINT16_MAX, UINT16_MAX, 11912, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 46, UINT16_MAX, UINT16_MAX, 11914, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 47, UINT16_MAX, UINT16_MAX, 11916, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 48, UINT16_MAX, UINT16_MAX, 11918, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 49, UINT16_MAX, UINT16_MAX, 11920, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 50, UINT16_MAX, UINT16_MAX, 11922, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 51, UINT16_MAX, UINT16_MAX, 11924, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28310, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 22717, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28312, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28314, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 44700, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28319, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11937, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11939, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11941, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11943, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11945, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11947, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11949, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11951, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11953, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11955, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11957, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11959, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11961, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11963, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11965, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11967, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11969, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11971, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11973, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11975, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11977, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11979, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11981, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11983, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11985, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11987, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 28373, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 28375, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 28377, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11995, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11997, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 11999, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12001, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12003, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12005, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12007, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12009, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12011, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12013, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12015, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12017, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12019, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12021, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12023, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12025, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12027, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12029, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12031, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12033, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12035, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12037, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12039, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12041, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12043, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 12045, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28431, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_REGIONAL_INDICATOR, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28433, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28435, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 5709, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 4901, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12053, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12054, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12055, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 4844, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12056, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12057, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 5281, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12058, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12059, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12060, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7077, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12061, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12062, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12063, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12064, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12065, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12066, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 4937, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12067, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12068, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12069, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12070, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12071, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12072, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 4838, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 5273, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12073, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 5622, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 5276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 5623, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12074, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 4993, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12075, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12076, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12077, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12078, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12079, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 5605, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 4911, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12080, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12081, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12082, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12083, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44852, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44855, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44858, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44861, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44864, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44867, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44870, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44873, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 44876, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12111, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12112, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12113, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12114, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12115, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12116, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12118, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12119, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12120, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12121, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12122, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12123, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12124, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12125, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12127, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12128, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12129, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12130, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12132, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12133, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12063, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12134, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12136, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12137, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12138, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12139, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12140, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4854, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12142, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12143, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12144, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12145, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12081, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12146, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12147, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12148, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12149, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12150, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12151, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12152, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12153, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12154, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12155, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12157, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12158, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12159, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12160, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12162, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12163, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12164, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12165, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12166, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12167, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12168, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12169, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12170, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12171, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12172, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12173, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12174, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12175, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12176, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12177, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12178, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12179, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12180, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12181, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12182, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12183, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12184, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12185, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12186, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12187, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12188, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12190, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12192, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12193, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12194, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12056, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12195, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12196, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12197, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12199, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12201, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12202, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12203, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12204, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12205, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12206, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12207, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12208, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12209, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12210, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12212, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12213, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12214, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12215, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12217, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12218, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12219, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4880, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12220, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12221, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12222, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12223, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12224, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12226, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12227, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12229, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12230, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12231, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12232, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12233, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12234, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12235, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12236, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12237, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12238, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12239, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12240, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12242, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12243, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12244, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12245, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12246, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4892, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12248, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12250, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12251, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12252, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12253, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12255, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12257, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12258, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12259, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12260, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12261, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12262, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12263, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12264, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12265, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12266, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12269, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12270, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12271, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12272, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12273, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12274, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12275, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12277, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12278, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12279, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12280, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12281, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12282, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12283, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12285, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12286, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12287, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12288, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12289, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12290, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12292, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12293, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12294, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12295, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12296, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12297, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12298, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12299, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12300, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12301, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12302, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12304, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12305, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12306, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12307, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12308, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12309, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12310, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12311, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12312, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12313, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12314, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12315, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12316, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12317, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12318, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12319, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12321, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12322, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12323, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12324, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12325, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12327, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12328, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12329, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12330, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12331, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12332, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12333, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12334, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12336, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12337, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12338, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12339, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12341, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12342, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12343, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12344, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12345, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12346, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12348, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12350, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12352, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12353, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12355, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12356, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12357, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12358, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12359, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12360, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12361, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12362, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12363, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12365, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12366, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12367, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12368, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12369, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12370, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12372, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12373, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12374, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12376, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12378, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12379, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12380, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12381, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12382, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12383, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12384, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12385, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12386, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12388, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12389, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12391, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12392, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12394, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12395, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12396, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12398, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12399, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12400, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12402, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12404, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12405, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12406, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12407, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12408, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12409, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12410, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12411, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12412, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12413, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12414, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12415, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12417, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12418, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12420, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12422, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12423, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12425, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12427, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12429, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12430, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12431, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12433, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12435, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12437, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12439, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12440, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12441, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12442, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12443, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12444, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12446, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12447, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12448, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12450, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12452, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12454, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12455, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12456, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12457, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12458, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12460, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12462, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12463, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12464, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12466, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12467, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12468, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12469, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12471, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12472, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12473, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12474, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12475, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12476, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12478, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12479, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12480, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12481, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12482, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12483, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12484, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12486, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12488, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12489, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12491, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12492, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12494, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12495, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12496, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12498, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12500, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12501, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12503, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12504, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12506, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12507, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12508, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12509, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12510, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12511, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12512, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12514, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12516, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12518, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12520, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12521, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12522, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12523, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12524, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12525, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12526, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12527, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12528, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12529, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12530, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12531, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12533, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12534, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12535, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12536, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12537, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12538, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12539, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12540, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12541, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12542, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12543, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12545, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12547, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12549, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12550, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12551, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12552, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12553, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12555, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12556, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12558, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12559, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12560, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12562, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12564, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12565, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12566, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12567, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12568, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12569, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12570, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12571, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12572, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12573, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12574, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12575, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12576, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12577, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12578, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12579, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4982, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12580, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12582, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12583, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12584, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12585, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12586, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12587, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12589, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12591, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12592, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12593, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4989, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12594, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12596, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12597, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12598, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12599, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12602, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12604, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12605, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12606, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12607, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12609, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12610, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12612, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12614, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12615, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12616, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12617, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12619, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12620, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12621, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12622, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12623, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12624, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12625, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12626, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12628, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12629, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12630, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12631, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12633, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12634, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12635, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12636, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12637, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12639, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12641, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12642, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12643, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12644, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12646, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12647, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12649, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12650, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12652, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12653, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12654, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12655, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12656, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12657, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12658, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12659, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12661, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12662, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12663, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12664, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12665, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12666, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12668, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12669, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12671, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12673, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5037, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12675, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5041, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12676, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12677, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12678, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12679, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5046, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 12680, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, + {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_BN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE}, }; static const utf8proc_uint16_t utf8proc_combinations[] = { @@ -14807,14 +16946,15 @@ static const utf8proc_uint16_t utf8proc_combinations[] = { 1, 5307, 1, 5308, 1, 5310, 68, 69, 1, 5562, 68, 69, 1, 5563, -70, 71, 1, 53598, -70, 71, 1, 53599, -72, 81, 1, 53600, - 1, 53601, 1, 53602, 1, 53603, 1, 53604, -70, 71, 1, 53691, -70, 71, 1, 53692, -72, 75, 1, 53693, 1, 53695, -72, 75, - 1, 53694, 1, 53696, +70, 71, 1, 6456, +72, 73, 1, 53598, +72, 73, 1, 53599, +74, 83, + 1, 53600, 1, 53601, 1, 53602, 1, 53603, 1, 53604, +72, 73, 1, 53691, +72, 73, 1, 53692, +74, 77, 1, 53693, + 1, 53695, +74, 77, 1, 53694, 1, 53696, }; diff --git a/third_party/utf8proc/utf8proc_wrapper.cpp b/third_party/utf8proc/utf8proc_wrapper.cpp index 9ff3615e8a8..40db1d609bd 100644 --- a/third_party/utf8proc/utf8proc_wrapper.cpp +++ b/third_party/utf8proc/utf8proc_wrapper.cpp @@ -1,6 +1,8 @@ #include "utf8proc_wrapper.hpp" #include "utf8proc.hpp" #include "duckdb/common/assert.hpp" +#include "duckdb/common/exception.hpp" + using namespace std; namespace duckdb { @@ -21,7 +23,8 @@ namespace duckdb { // 3 U+000800 U+00FFFF 1110xxxx // 4 U+010000 U+10FFFF 11110xxx -static void AssignInvalidUTF8Reason(UnicodeInvalidReason *invalid_reason, size_t *invalid_pos, size_t pos, UnicodeInvalidReason reason) { +static void AssignInvalidUTF8Reason(UnicodeInvalidReason *invalid_reason, size_t *invalid_pos, size_t pos, + UnicodeInvalidReason reason) { if (invalid_reason) { *invalid_reason = reason; } @@ -31,16 +34,16 @@ static void AssignInvalidUTF8Reason(UnicodeInvalidReason *invalid_reason, size_t } template -static inline UnicodeType -UTF8ExtraByteLoop(const int first_pos_seq, int utf8char, size_t& i, - const char *s, const size_t len, UnicodeInvalidReason *invalid_reason, size_t *invalid_pos) { +static inline UnicodeType UTF8ExtraByteLoop(const int first_pos_seq, int utf8char, size_t &i, const char *s, + const size_t len, UnicodeInvalidReason *invalid_reason, + size_t *invalid_pos) { if ((len - i) < (nextra_bytes + 1)) { /* incomplete byte sequence */ AssignInvalidUTF8Reason(invalid_reason, invalid_pos, first_pos_seq, UnicodeInvalidReason::BYTE_MISMATCH); return UnicodeType::INVALID; } - for (size_t j = 0 ; j < nextra_bytes; j++) { - int c = (int) s[++i]; + for (size_t j = 0; j < nextra_bytes; j++) { + int c = (int)s[++i]; /* now validate the extra bytes */ if ((c & 0xC0) != 0x80) { /* extra byte is not in the format 10xxxxxx */ @@ -60,7 +63,8 @@ UTF8ExtraByteLoop(const int first_pos_seq, int utf8char, size_t& i, return UnicodeType::INVALID; } if ((utf8char & 0x1FFF800) == 0xD800) { - /* Unicode characters from U+D800 to U+DFFF are surrogate characters used by UTF-16 which are invalid in UTF-8 */ + /* Unicode characters from U+D800 to U+DFFF are surrogate characters used by UTF-16 which are invalid in UTF-8 + */ AssignInvalidUTF8Reason(invalid_reason, invalid_pos, first_pos_seq, UnicodeInvalidReason::INVALID_UNICODE); return UnicodeType::INVALID; } @@ -71,7 +75,7 @@ UnicodeType Utf8Proc::Analyze(const char *s, size_t len, UnicodeInvalidReason *i UnicodeType type = UnicodeType::ASCII; for (size_t i = 0; i < len; i++) { - int c = (int) s[i]; + int c = (int)s[i]; if ((c & 0x80) == 0) { continue; @@ -102,11 +106,11 @@ UnicodeType Utf8Proc::Analyze(const char *s, size_t len, UnicodeInvalidReason *i return type; } -void Utf8Proc::MakeValid(char *s, size_t len, char special_flag){ - D_ASSERT(special_flag <=127); +void Utf8Proc::MakeValid(char *s, size_t len, char special_flag) { + D_ASSERT(special_flag <= 127); UnicodeType type = UnicodeType::ASCII; for (size_t i = 0; i < len; i++) { - int c = (int) s[i]; + int c = (int)s[i]; if ((c & 0x80) == 0) { continue; } @@ -129,18 +133,18 @@ void Utf8Proc::MakeValid(char *s, size_t len, char special_flag){ } if (type == UnicodeType::INVALID) { for (size_t j = first_pos_seq; j <= i; j++) { - s[j] = special_flag; // Rewrite each byte of the invalid sequence - } + s[j] = special_flag; // Rewrite each byte of the invalid sequence + } type = UnicodeType::ASCII; } } - D_ASSERT(Utf8Proc::IsValid(s,len)); + D_ASSERT(Utf8Proc::IsValid(s, len)); } -char* Utf8Proc::Normalize(const char *s, size_t len) { +char *Utf8Proc::Normalize(const char *s, size_t len) { assert(s); assert(Utf8Proc::Analyze(s, len) != UnicodeType::INVALID); - return (char*) utf8proc_NFC((const utf8proc_uint8_t*) s, len); + return (char *)utf8proc_NFC((const utf8proc_uint8_t *)s, len); } bool Utf8Proc::IsValid(const char *s, size_t len) { @@ -148,7 +152,97 @@ bool Utf8Proc::IsValid(const char *s, size_t len) { } size_t Utf8Proc::NextGraphemeCluster(const char *s, size_t len, size_t cpos) { - return utf8proc_next_grapheme(s, len, cpos); + int sz; + auto prev_codepoint = Utf8Proc::UTF8ToCodepoint(s + cpos, sz); + utf8proc_int32_t state = 0; + while (true) { + cpos += sz; + if (cpos >= len) { + return cpos; + } + auto next_codepoint = Utf8Proc::UTF8ToCodepoint(s + cpos, sz); + if (utf8proc_grapheme_break_stateful(prev_codepoint, next_codepoint, &state)) { + // found a grapheme break here + return cpos; + } + // not a grapheme break, move on to next codepoint + prev_codepoint = next_codepoint; + } +} + +size_t Utf8Proc::GraphemeCount(const char *input_data, size_t input_size) { + size_t num_characters = 0; + for (auto cluster : Utf8Proc::GraphemeClusters(input_data, input_size)) { + (void)cluster; + num_characters++; + } + return num_characters; +} + +int32_t Utf8Proc::CodepointToUpper(int32_t codepoint) { + return utf8proc_toupper(codepoint); +} + +int32_t Utf8Proc::CodepointToLower(int32_t codepoint) { + return utf8proc_tolower(codepoint); +} + +GraphemeIterator::GraphemeIterator(const char *s, size_t len) : s(s), len(len) { +} + +GraphemeIterator Utf8Proc::GraphemeClusters(const char *s, size_t len) { + return GraphemeIterator(s, len); +} + +GraphemeIterator::GraphemeClusterIterator::GraphemeClusterIterator(const char *s_p, size_t len_p) : s(s_p), len(len_p) { + if (s) { + cluster.start = 0; + cluster.end = 0; + Next(); + } else { + SetInvalid(); + } +} + +void GraphemeIterator::GraphemeClusterIterator::SetInvalid() { + s = nullptr; + len = 0; + cluster.start = 0; + cluster.end = 0; +} + +bool GraphemeIterator::GraphemeClusterIterator::IsInvalid() const { + return !s; +} + +void GraphemeIterator::GraphemeClusterIterator::Next() { + if (IsInvalid()) { + throw std::runtime_error("Grapheme cluster out of bounds!"); + } + if (cluster.end >= len) { + // out of bounds + SetInvalid(); + return; + } + size_t next_pos = Utf8Proc::NextGraphemeCluster(s, len, cluster.end); + cluster.start = cluster.end; + cluster.end = next_pos; +} + +GraphemeIterator::GraphemeClusterIterator &GraphemeIterator::GraphemeClusterIterator::operator++() { + Next(); + return *this; +} +bool GraphemeIterator::GraphemeClusterIterator::operator!=(const GraphemeClusterIterator &other) const { + return !(len == other.len && s == other.s && cluster.start == other.cluster.start && + cluster.end == other.cluster.end); +} + +GraphemeCluster GraphemeIterator::GraphemeClusterIterator::operator*() const { + if (IsInvalid()) { + throw std::runtime_error("Grapheme cluster out of bounds!"); + } + return cluster; } size_t Utf8Proc::PreviousGraphemeCluster(const char *s, size_t len, size_t cpos) { @@ -156,7 +250,7 @@ size_t Utf8Proc::PreviousGraphemeCluster(const char *s, size_t len, size_t cpos) return cpos - 1; } size_t current_pos = 0; - while(true) { + while (true) { size_t new_pos = NextGraphemeCluster(s, len, current_pos); if (new_pos <= current_pos || new_pos >= cpos) { return current_pos; @@ -166,30 +260,92 @@ size_t Utf8Proc::PreviousGraphemeCluster(const char *s, size_t len, size_t cpos) } bool Utf8Proc::CodepointToUtf8(int cp, int &sz, char *c) { - return utf8proc_codepoint_to_utf8(cp, sz, c); + if (cp <= 0x7F) { + sz = 1; + c[0] = cp; + } else if (cp <= 0x7FF) { + sz = 2; + c[0] = (cp >> 6) + 192; + c[1] = (cp & 63) + 128; + } else if (0xd800 <= cp && cp <= 0xdfff) { + sz = -1; + // invalid block of utf + return false; + } else if (cp <= 0xFFFF) { + sz = 3; + c[0] = (cp >> 12) + 224; + c[1] = ((cp >> 6) & 63) + 128; + c[2] = (cp & 63) + 128; + } else if (cp <= 0x10FFFF) { + sz = 4; + c[0] = (cp >> 18) + 240; + c[1] = ((cp >> 12) & 63) + 128; + c[2] = ((cp >> 6) & 63) + 128; + c[3] = (cp & 63) + 128; + } else { + sz = -1; + return false; + } + return true; } int Utf8Proc::CodepointLength(int cp) { - return utf8proc_codepoint_length(cp); + if (cp <= 0x7F) { + return 1; + } else if (cp <= 0x7FF) { + return 2; + } else if (0xd800 <= cp && cp <= 0xdfff) { + return -1; + } else if (cp <= 0xFFFF) { + return 3; + } else if (cp <= 0x10FFFF) { + return 4; + } + return -1; } -int32_t Utf8Proc::UTF8ToCodepoint(const char *c, int &sz) { - return utf8proc_codepoint(c, sz); +int32_t Utf8Proc::UTF8ToCodepoint(const char *u_input, int &sz) { + // from http://www.zedwood.com/article/cpp-utf8-char-to-codepoint + auto u = reinterpret_cast(u_input); + unsigned char u0 = u[0]; + if (u0 <= 127) { + sz = 1; + return u0; + } + unsigned char u1 = u[1]; + if (u0 >= 192 && u0 <= 223) { + sz = 2; + return (u0 - 192) * 64 + (u1 - 128); + } + if (u[0] == 0xed && (u[1] & 0xa0) == 0xa0) { + return -1; // code points, 0xd800 to 0xdfff + } + unsigned char u2 = u[2]; + if (u0 >= 224 && u0 <= 239) { + sz = 3; + return (u0 - 224) * 4096 + (u1 - 128) * 64 + (u2 - 128); + } + unsigned char u3 = u[3]; + if (u0 >= 240 && u0 <= 247) { + sz = 4; + return (u0 - 240) * 262144 + (u1 - 128) * 4096 + (u2 - 128) * 64 + (u3 - 128); + } + return -1; } size_t Utf8Proc::RenderWidth(const char *s, size_t len, size_t pos) { - int sz; - auto codepoint = duckdb::utf8proc_codepoint(s + pos, sz); - auto properties = duckdb::utf8proc_get_property(codepoint); - return properties->charwidth; + int sz; + auto codepoint = Utf8Proc::UTF8ToCodepoint(s + pos, sz); + auto properties = duckdb::utf8proc_get_property(codepoint); + return properties->charwidth; } size_t Utf8Proc::RenderWidth(const std::string &str) { size_t render_width = 0; size_t pos = 0; - while(pos < str.size()) { + while (pos < str.size()) { int sz; - auto codepoint = duckdb::utf8proc_codepoint(str.c_str() + pos, sz); + auto codepoint = Utf8Proc::UTF8ToCodepoint(str.c_str() + pos, sz); auto properties = duckdb::utf8proc_get_property(codepoint); render_width += properties->charwidth; pos += sz; @@ -197,4 +353,4 @@ size_t Utf8Proc::RenderWidth(const std::string &str) { return render_width; } -} +} // namespace duckdb diff --git a/tools/juliapkg/Project.toml b/tools/juliapkg/Project.toml index 6914a8f38ee..061d50a90ab 100644 --- a/tools/juliapkg/Project.toml +++ b/tools/juliapkg/Project.toml @@ -1,7 +1,7 @@ name = "DuckDB" uuid = "d2f5444f-75bc-4fdf-ac35-56f514c445e1" authors = ["Mark Raasveldt "] -version = "0.10.2" +version = "1.0.0" [deps] DBInterface = "a10d1c49-ce27-4219-8d33-6db1a4562965" @@ -14,7 +14,7 @@ WeakRefStrings = "ea10d353-3f73-51f8-a26c-33c1cb351aa5" [compat] DBInterface = "2.5" -DuckDB_jll = "0.10.2" +DuckDB_jll = "1.0.0" FixedPointDecimals = "0.4, 0.5" Tables = "1.7" WeakRefStrings = "1.4" diff --git a/tools/juliapkg/release.py b/tools/juliapkg/release.py index ba2f0d1cbdd..8d1d09fa3c1 100644 --- a/tools/juliapkg/release.py +++ b/tools/juliapkg/release.py @@ -36,7 +36,13 @@ def run_syscall(syscall, ignore_failure=False): proc = subprocess.Popen(['git', 'show-ref', '--tags'], stdout=subprocess.PIPE) tags = [x for x in proc.stdout.read().decode('utf8').split('\n') if len(x) > 0 and 'master-builds' not in x] -tags.sort(key=lambda x: int(x.split('refs/tags/')[1].split('.')[1])) + +def extract_tag(x): + keys = x.split('refs/tags/')[1].lstrip('v').split('.') + return int(keys[0]) * 10000000 + int(keys[1]) * 10000 + int(keys[2]) + + +tags.sort(key=extract_tag) # latest tag splits = tags[-1].split(' ') diff --git a/tools/pythonpkg/duckdb-stubs/__init__.pyi b/tools/pythonpkg/duckdb-stubs/__init__.pyi index 3ca7649f2ef..7bcb25ec6f4 100644 --- a/tools/pythonpkg/duckdb-stubs/__init__.pyi +++ b/tools/pythonpkg/duckdb-stubs/__init__.pyi @@ -286,7 +286,7 @@ class DuckDBPyConnection: def row_type(self, fields: Union[Dict[str, DuckDBPyType], List[str]]) -> DuckDBPyType: ... def map_type(self, key: DuckDBPyType, value: DuckDBPyType) -> DuckDBPyType: ... def duplicate(self) -> DuckDBPyConnection: ... - def execute(self, query: object, parameters: object = None, multiple_parameter_sets: bool = False) -> DuckDBPyConnection: ... + def execute(self, query: object, parameters: object = None) -> DuckDBPyConnection: ... def executemany(self, query: object, parameters: object = None) -> DuckDBPyConnection: ... def close(self) -> None: ... def interrupt(self) -> None: ... @@ -611,7 +611,7 @@ def struct_type(fields: Union[Dict[str, DuckDBPyType], List[str]], *, connection def row_type(fields: Union[Dict[str, DuckDBPyType], List[str]], *, connection: DuckDBPyConnection = ...) -> DuckDBPyType: ... def map_type(key: DuckDBPyType, value: DuckDBPyType, *, connection: DuckDBPyConnection = ...) -> DuckDBPyType: ... def duplicate(*, connection: DuckDBPyConnection = ...) -> DuckDBPyConnection: ... -def execute(query: object, parameters: object = None, multiple_parameter_sets: bool = False, *, connection: DuckDBPyConnection = ...) -> DuckDBPyConnection: ... +def execute(query: object, parameters: object = None, *, connection: DuckDBPyConnection = ...) -> DuckDBPyConnection: ... def executemany(query: object, parameters: object = None, *, connection: DuckDBPyConnection = ...) -> DuckDBPyConnection: ... def close(*, connection: DuckDBPyConnection = ...) -> None: ... def interrupt(*, connection: DuckDBPyConnection = ...) -> None: ... diff --git a/tools/pythonpkg/duckdb_python.cpp b/tools/pythonpkg/duckdb_python.cpp index 903079c8c60..5e651bccec2 100644 --- a/tools/pythonpkg/duckdb_python.cpp +++ b/tools/pythonpkg/duckdb_python.cpp @@ -279,16 +279,14 @@ static void InitializeConnectionMethods(py::module_ &m) { "Create a duplicate of the current connection", py::kw_only(), py::arg("connection") = py::none()); m.def( "execute", - [](const py::object &query, py::object params, bool many = false, - shared_ptr conn = nullptr) { + [](const py::object &query, py::object params, shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } - return conn->Execute(query, params, many); + return conn->Execute(query, params); }, "Execute the given SQL query, optionally using prepared statements with parameters set", py::arg("query"), - py::arg("parameters") = py::none(), py::arg("multiple_parameter_sets") = false, py::kw_only(), - py::arg("connection") = py::none()); + py::arg("parameters") = py::none(), py::kw_only(), py::arg("connection") = py::none()); m.def( "executemany", [](const py::object &query, py::object params, shared_ptr conn = nullptr) { @@ -587,8 +585,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "sql", - [](const py::object &query, string alias, const py::object ¶ms, - shared_ptr conn = nullptr) { + [](const py::object &query, string alias, py::object params, shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -600,8 +597,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "query", - [](const py::object &query, string alias, const py::object ¶ms, - shared_ptr conn = nullptr) { + [](const py::object &query, string alias, py::object params, shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -613,8 +609,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "from_query", - [](const py::object &query, string alias, const py::object ¶ms, - shared_ptr conn = nullptr) { + [](const py::object &query, string alias, py::object params, shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } diff --git a/tools/pythonpkg/scripts/connection_methods.json b/tools/pythonpkg/scripts/connection_methods.json index 94810f898fa..abbf5b0299e 100644 --- a/tools/pythonpkg/scripts/connection_methods.json +++ b/tools/pythonpkg/scripts/connection_methods.json @@ -260,11 +260,6 @@ "name": "parameters", "default": "None", "type": "object" - }, - { - "name": "multiple_parameter_sets", - "default": "False", - "type": "bool" } ], "return": "DuckDBPyConnection" diff --git a/tools/pythonpkg/src/include/duckdb_python/pandas/pandas_analyzer.hpp b/tools/pythonpkg/src/include/duckdb_python/pandas/pandas_analyzer.hpp index d91ba23f748..70098c33bb0 100644 --- a/tools/pythonpkg/src/include/duckdb_python/pandas/pandas_analyzer.hpp +++ b/tools/pythonpkg/src/include/duckdb_python/pandas/pandas_analyzer.hpp @@ -19,11 +19,13 @@ namespace duckdb { class PandasAnalyzer { public: - explicit PandasAnalyzer(const DBConfig &config) { + explicit PandasAnalyzer(const ClientContext &context) { analyzed_type = LogicalType::SQLNULL; - auto maximum_entry = config.options.set_variables.find("pandas_analyze_sample"); - D_ASSERT(maximum_entry != config.options.set_variables.end()); - sample_size = maximum_entry->second.GetValue(); + + Value result; + auto lookup_result = context.TryGetCurrentSetting("pandas_analyze_sample", result); + D_ASSERT((bool)lookup_result); + sample_size = result.GetValue(); } public: diff --git a/tools/pythonpkg/src/include/duckdb_python/pyconnection/pyconnection.hpp b/tools/pythonpkg/src/include/duckdb_python/pyconnection/pyconnection.hpp index b211c0c309a..ae6b5ed46fa 100644 --- a/tools/pythonpkg/src/include/duckdb_python/pyconnection/pyconnection.hpp +++ b/tools/pythonpkg/src/include/duckdb_python/pyconnection/pyconnection.hpp @@ -114,10 +114,11 @@ struct DuckDBPyConnection : public enable_shared_from_this { shared_ptr ExecuteMany(const py::object &query, py::object params = py::list()); - unique_ptr ExecuteInternal(vector> statements, py::object params = py::list(), - bool many = false); + void ExecuteImmediately(vector> statements); + unique_ptr PrepareQuery(unique_ptr statement); + unique_ptr ExecuteInternal(PreparedStatement &prep, py::object params = py::list()); - shared_ptr Execute(const py::object &query, py::object params = py::list(), bool many = false); + shared_ptr Execute(const py::object &query, py::object params = py::list()); shared_ptr ExecuteFromString(const string &query); shared_ptr Append(const string &name, const PandasDataFrame &value, bool by_name); @@ -128,8 +129,7 @@ struct DuckDBPyConnection : public enable_shared_from_this { void LoadExtension(const string &extension); - unique_ptr RunQuery(const py::object &query, string alias = "", - const py::object ¶ms = py::none()); + unique_ptr RunQuery(const py::object &query, string alias = "", py::object params = py::list()); unique_ptr Table(const string &tname); diff --git a/tools/pythonpkg/src/numpy/numpy_bind.cpp b/tools/pythonpkg/src/numpy/numpy_bind.cpp index 05ea0dbf8a5..ae334badc72 100644 --- a/tools/pythonpkg/src/numpy/numpy_bind.cpp +++ b/tools/pythonpkg/src/numpy/numpy_bind.cpp @@ -10,7 +10,6 @@ namespace duckdb { void NumpyBind::Bind(const ClientContext &context, py::handle df, vector &bind_columns, vector &return_types, vector &names) { - auto &config = DBConfig::GetConfig(context); auto df_columns = py::list(df.attr("keys")()); auto df_types = py::list(); for (auto item : py::cast(df)) { @@ -61,7 +60,7 @@ void NumpyBind::Bind(const ClientContext &context, py::handle df, vector @@ -164,7 +165,7 @@ static void InitializeConnectionMethods(py::class_ DuckDBPyConnection::ExecuteMany(const py::object &query, py::object params) { - if (params.is_none()) { - params = py::list(); +shared_ptr DuckDBPyConnection::ExecuteMany(const py::object &query, py::object params_p) { + result.reset(); + if (params_p.is_none()) { + params_p = py::list(); + } + + auto statements = GetStatements(query); + if (statements.empty()) { + // TODO: should we throw? + return nullptr; + } + + auto last_statement = std::move(statements.back()); + statements.pop_back(); + // First immediately execute any preceding statements (if any) + // FIXME: DBAPI says to not accept an 'executemany' call with multiple statements + ExecuteImmediately(std::move(statements)); + + auto prep = PrepareQuery(std::move(last_statement)); + + if (!py::isinstance(params_p)) { + throw InvalidInputException("executemany requires a list of parameter sets to be provided"); } - Execute(query, std::move(params), true); + auto outer_list = py::list(params_p); + if (outer_list.empty()) { + throw InvalidInputException("executemany requires a non-empty list of parameter sets to be provided"); + } + + unique_ptr query_result; + // Execute once for every set of parameters that are provided + for (auto ¶meters : outer_list) { + auto params = py::reinterpret_borrow(parameters); + query_result = ExecuteInternal(*prep, std::move(params)); + } + // Set the internal 'result' object + if (query_result) { + auto py_result = make_uniq(std::move(query_result)); + result = make_uniq(std::move(py_result)); + } + return shared_from_this(); } @@ -486,99 +522,65 @@ py::list TransformNamedParameters(const case_insensitive_map_t &named_par return new_params; } -unique_ptr DuckDBPyConnection::ExecuteInternal(vector> statements, - py::object params, bool many) { - if (!connection) { - throw ConnectionException("Connection has already been closed"); - } - if (params.is_none()) { - params = py::list(); +case_insensitive_map_t TransformPreparedParameters(PreparedStatement &prep, const py::object ¶ms) { + case_insensitive_map_t named_values; + if (py::isinstance(params) || py::isinstance(params)) { + if (prep.n_param != py::len(params)) { + throw InvalidInputException("Prepared statement needs %d parameters, %d given", prep.n_param, + py::len(params)); + } + auto unnamed_values = DuckDBPyConnection::TransformPythonParamList(params); + for (idx_t i = 0; i < unnamed_values.size(); i++) { + auto &value = unnamed_values[i]; + auto identifier = std::to_string(i + 1); + named_values[identifier] = std::move(value); + } + } else if (py::isinstance(params)) { + auto dict = py::cast(params); + named_values = DuckDBPyConnection::TransformPythonParamDict(dict); + } else { + throw InvalidInputException("Prepared parameters can only be passed as a list or a dictionary"); } - result = nullptr; + return named_values; +} + +unique_ptr DuckDBPyConnection::PrepareQuery(unique_ptr statement) { unique_ptr prep; { py::gil_scoped_release release; - unique_lock lock(py_connection_lock); + unique_lock lock(py_connection_lock); - if (statements.empty()) { - // no statements to execute - return nullptr; - } - // if there are multiple statements, we directly execute the statements besides the last one - // we only return the result of the last statement to the user, unless one of the previous statements fails - for (idx_t i = 0; i + 1 < statements.size(); i++) { - if (statements[i]->n_param != 0) { - throw NotImplementedException( - "Prepared parameters are only supported for the last statement, please split your query up into " - "separate 'execute' calls if you want to use prepared parameters"); - } - auto pending_query = connection->PendingQuery(std::move(statements[i]), false); - auto res = CompletePendingQuery(*pending_query); - - if (res->HasError()) { - res->ThrowError(); - } - } - - prep = connection->Prepare(std::move(statements.back())); + prep = connection->Prepare(std::move(statement)); if (prep->HasError()) { prep->error.Throw(); } } + return prep; +} - // this is a list of a list of parameters in executemany - py::list params_set; - if (!many) { - params_set = py::list(1); - params_set[0] = params; - } else { - if (!py::isinstance(params)) { - throw InvalidInputException("executemany requires a list of parameter sets to be provided"); - } - auto outer_list = py::list(params); - if (outer_list.empty()) { - throw InvalidInputException("executemany requires a non-empty list of parameter sets to be provided"); - } - params_set = params; +unique_ptr DuckDBPyConnection::ExecuteInternal(PreparedStatement &prep, py::object params) { + if (!connection) { + throw ConnectionException("Connection has already been closed"); + } + if (params.is_none()) { + params = py::list(); } - // For every entry of the argument list, execute the prepared statement with said arguments - for (pybind11::handle single_query_params : params_set) { - case_insensitive_map_t named_values; - if (py::isinstance(single_query_params) || py::isinstance(single_query_params)) { - if (prep->n_param != py::len(single_query_params)) { - throw InvalidInputException("Prepared statement needs %d parameters, %d given", prep->n_param, - py::len(single_query_params)); - } - auto unnamed_values = DuckDBPyConnection::TransformPythonParamList(single_query_params); - for (idx_t i = 0; i < unnamed_values.size(); i++) { - auto &value = unnamed_values[i]; - auto identifier = std::to_string(i + 1); - named_values[identifier] = std::move(value); - } - } else if (py::isinstance(single_query_params)) { - auto dict = py::cast(single_query_params); - named_values = DuckDBPyConnection::TransformPythonParamDict(dict); - } else { - throw InvalidInputException("Prepared parameters can only be passed as a list or a dictionary"); - } - unique_ptr res; - { - py::gil_scoped_release release; - unique_lock lock(py_connection_lock); - auto pending_query = prep->PendingQuery(named_values); - res = CompletePendingQuery(*pending_query); + // Execute the prepared statement with the prepared parameters + auto named_values = TransformPreparedParameters(prep, params); + unique_ptr res; + { + py::gil_scoped_release release; + unique_lock lock(py_connection_lock); - if (res->HasError()) { - res->ThrowError(); - } - } + auto pending_query = prep.PendingQuery(named_values); + res = CompletePendingQuery(*pending_query); - if (!many) { - return res; + if (res->HasError()) { + res->ThrowError(); } } - return nullptr; + return res; } vector> DuckDBPyConnection::GetStatements(const py::object &query) { @@ -603,10 +605,25 @@ shared_ptr DuckDBPyConnection::ExecuteFromString(const strin return Execute(py::str(query)); } -shared_ptr DuckDBPyConnection::Execute(const py::object &query, py::object params, bool many) { +shared_ptr DuckDBPyConnection::Execute(const py::object &query, py::object params) { + result.reset(); + auto statements = GetStatements(query); + if (statements.empty()) { + // TODO: should we throw? + return nullptr; + } + + auto last_statement = std::move(statements.back()); + statements.pop_back(); + // First immediately execute any preceding statements (if any) + // FIXME: SQLites implementation says to not accept an 'execute' call with multiple statements + ExecuteImmediately(std::move(statements)); + + auto prep = PrepareQuery(std::move(last_statement)); + auto res = ExecuteInternal(*prep, std::move(params)); - auto res = ExecuteInternal(std::move(statements), std::move(params), many); + // Set the internal 'result' object if (res) { auto py_result = make_uniq(std::move(res)); result = make_uniq(std::move(py_result)); @@ -1022,8 +1039,26 @@ unique_ptr DuckDBPyConnection::ReadCSV( return make_uniq(read_csv_p->Alias(read_csv.alias)); } -unique_ptr DuckDBPyConnection::RunQuery(const py::object &query, string alias, - const py::object ¶ms) { +void DuckDBPyConnection::ExecuteImmediately(vector> statements) { + if (statements.empty()) { + return; + } + for (auto &stmt : statements) { + if (stmt->n_param != 0) { + throw NotImplementedException( + "Prepared parameters are only supported for the last statement, please split your query up into " + "separate 'execute' calls if you want to use prepared parameters"); + } + auto pending_query = connection->PendingQuery(std::move(stmt), false); + auto res = CompletePendingQuery(*pending_query); + + if (res->HasError()) { + res->ThrowError(); + } + } +} + +unique_ptr DuckDBPyConnection::RunQuery(const py::object &query, string alias, py::object params) { if (!connection) { throw ConnectionException("Connection has already been closed"); } @@ -1032,25 +1067,51 @@ unique_ptr DuckDBPyConnection::RunQuery(const py::object &quer } auto statements = GetStatements(query); - if (statements.size() == 1 && statements[0]->type == StatementType::SELECT_STATEMENT && py::none().is(params)) { - auto select_statement = unique_ptr_cast(std::move(statements[0])); - return make_uniq(connection->RelationFromQuery(std::move(select_statement), alias)); - } - - auto res = ExecuteInternal(std::move(statements), params); - if (!res) { + if (statements.empty()) { + // TODO: should we throw? return nullptr; } - if (res->properties.return_type != StatementReturnType::QUERY_RESULT) { - return nullptr; + + auto last_statement = std::move(statements.back()); + statements.pop_back(); + // First immediately execute any preceding statements (if any) + ExecuteImmediately(std::move(statements)); + + // Attempt to create a Relation for lazy execution if possible + shared_ptr relation; + if (py::none().is(params)) { + // FIXME: currently we can't create relations with prepared parameters + auto statement_type = last_statement->type; + switch (statement_type) { + case StatementType::SELECT_STATEMENT: { + auto select_statement = unique_ptr_cast(std::move(last_statement)); + relation = connection->RelationFromQuery(std::move(select_statement), alias); + break; + } + default: + break; + } } - if (res->type == QueryResultType::STREAM_RESULT) { - auto &stream_result = res->Cast(); - res = stream_result.Materialize(); + + if (!relation) { + // Could not create a relation, resort to direct execution + auto prep = PrepareQuery(std::move(last_statement)); + auto res = ExecuteInternal(*prep, std::move(params)); + if (!res) { + return nullptr; + } + if (res->properties.return_type != StatementReturnType::QUERY_RESULT) { + return nullptr; + } + if (res->type == QueryResultType::STREAM_RESULT) { + auto &stream_result = res->Cast(); + res = stream_result.Materialize(); + } + auto &materialized_result = res->Cast(); + relation = make_shared_ptr(connection->context, materialized_result.TakeCollection(), + res->names, alias); } - auto &materialized_result = res->Cast(); - return make_uniq( - make_uniq(connection->context, materialized_result.TakeCollection(), res->names, alias)); + return make_uniq(std::move(relation)); } unique_ptr DuckDBPyConnection::Table(const string &tname) { diff --git a/tools/pythonpkg/src/pyexpression/initialize.cpp b/tools/pythonpkg/src/pyexpression/initialize.cpp index 39ef1511387..5f7b784459f 100644 --- a/tools/pythonpkg/src/pyexpression/initialize.cpp +++ b/tools/pythonpkg/src/pyexpression/initialize.cpp @@ -318,7 +318,7 @@ void DuckDBPyExpression::Initialize(py::module_ &m) { expression.def("isnotnull", &DuckDBPyExpression::IsNotNull, docs); docs = R"( - Return a IN expression comparing self to the input arguments. + Return an IN expression comparing self to the input arguments. Returns: DuckDBPyExpression: The compare IN expression diff --git a/tools/pythonpkg/src/pyrelation.cpp b/tools/pythonpkg/src/pyrelation.cpp index 01ac87218d3..bf54bdcd88b 100644 --- a/tools/pythonpkg/src/pyrelation.cpp +++ b/tools/pythonpkg/src/pyrelation.cpp @@ -1394,6 +1394,9 @@ string DuckDBPyRelation::ToStringInternal(const BoxRendererConfig &config, bool string DuckDBPyRelation::ToString() { BoxRendererConfig config; config.limit = 10000; + if (DuckDBPyConnection::IsJupyter()) { + config.max_width = 10000; + } return ToStringInternal(config); } @@ -1407,6 +1410,9 @@ void DuckDBPyRelation::Print(const Optional &max_width, const Optional const py::object &render_mode) { BoxRendererConfig config; config.limit = 10000; + if (DuckDBPyConnection::IsJupyter()) { + config.max_width = 10000; + } bool invalidate_cache = false; if (!py::none().is(max_width)) { diff --git a/tools/pythonpkg/src/python_replacement_scan.cpp b/tools/pythonpkg/src/python_replacement_scan.cpp index 8c0d136afb8..2119f7e5855 100644 --- a/tools/pythonpkg/src/python_replacement_scan.cpp +++ b/tools/pythonpkg/src/python_replacement_scan.cpp @@ -187,35 +187,8 @@ unique_ptr PythonReplacementScan::Replace(ClientContext &context, Repl return nullptr; } - auto &table_ref = input.ref; - if (table_ref.external_dependency) { - auto dependency_item = table_ref.external_dependency->GetDependency("replacement_cache"); - if (dependency_item) { - py::gil_scoped_acquire acquire; - auto &python_dependency = dependency_item->Cast(); - auto ®istered_object = *python_dependency.object; - auto &py_object = registered_object.obj; - auto result = TryReplacementObject(py_object, table_name, context); - // This was cached, so it was successful before, it should be successfull now - D_ASSERT(result); - return std::move(result); - } - } - unique_ptr result; result = ReplaceInternal(context, table_name); - if (!result) { - return nullptr; - } - if (table_ref.external_dependency) { - D_ASSERT(result->external_dependency); - - D_ASSERT(result->external_dependency->GetDependency("replacement_cache") != nullptr); - result->external_dependency->ScanDependencies( - [&table_ref](const string &name, shared_ptr item) { - table_ref.external_dependency->AddDependency(name, std::move(item)); - }); - } return result; } diff --git a/tools/pythonpkg/tests/fast/pandas/test_df_analyze.py b/tools/pythonpkg/tests/fast/pandas/test_df_analyze.py index 578cb2fee72..114f8e3fb82 100644 --- a/tools/pythonpkg/tests/fast/pandas/test_df_analyze.py +++ b/tools/pythonpkg/tests/fast/pandas/test_df_analyze.py @@ -14,7 +14,7 @@ class TestResolveObjectColumns(object): def test_sample_low_correct(self, duckdb_cursor, pandas): print(pandas.backend) duckdb_conn = duckdb.connect() - duckdb_conn.execute("SET GLOBAL pandas_analyze_sample=3") + duckdb_conn.execute("SET pandas_analyze_sample=3") data = [1000008, 6, 9, 4, 1, 6] df = create_generic_dataframe(data, pandas) roundtripped_df = duckdb.query_df(df, "x", "select * from x", connection=duckdb_conn).df() @@ -24,7 +24,7 @@ def test_sample_low_correct(self, duckdb_cursor, pandas): @pytest.mark.parametrize('pandas', [NumpyPandas(), ArrowPandas()]) def test_sample_low_incorrect_detected(self, duckdb_cursor, pandas): duckdb_conn = duckdb.connect() - duckdb_conn.execute("SET GLOBAL pandas_analyze_sample=2") + duckdb_conn.execute("SET pandas_analyze_sample=2") # size of list (6) divided by 'pandas_analyze_sample' (2) is the increment used # in this case index 0 (1000008) and index 3 ([4]) are checked, which dont match data = [1000008, 6, 9, [4], 1, 6] @@ -37,7 +37,7 @@ def test_sample_low_incorrect_detected(self, duckdb_cursor, pandas): def test_sample_zero(self, duckdb_cursor, pandas): duckdb_conn = duckdb.connect() # Disable dataframe analyze - duckdb_conn.execute("SET GLOBAL pandas_analyze_sample=0") + duckdb_conn.execute("SET pandas_analyze_sample=0") data = [1000008, 6, 9, 3, 1, 6] df = create_generic_dataframe(data, pandas) roundtripped_df = duckdb.query_df(df, "x", "select * from x", connection=duckdb_conn).df() @@ -50,13 +50,21 @@ def test_sample_zero(self, duckdb_cursor, pandas): @pytest.mark.parametrize('pandas', [NumpyPandas(), ArrowPandas()]) def test_sample_low_incorrect_undetected(self, duckdb_cursor, pandas): duckdb_conn = duckdb.connect() - duckdb_conn.execute("SET GLOBAL pandas_analyze_sample=1") + duckdb_conn.execute("SET pandas_analyze_sample=1") data = [1000008, 6, 9, [4], [1], 6] df = create_generic_dataframe(data, pandas) # Sample size is too low to detect the mismatch, exception is raised when trying to convert with pytest.raises(duckdb.InvalidInputException, match="Failed to cast value: Unimplemented type for cast"): roundtripped_df = duckdb.query_df(df, "x", "select * from x", connection=duckdb_conn).df() + def test_reset_analyze_sample_setting(self, duckdb_cursor): + duckdb_cursor.execute("SET pandas_analyze_sample=5") + res = duckdb_cursor.execute("select current_setting('pandas_analyze_sample')").fetchall() + assert res == [(5,)] + duckdb_cursor.execute("reset pandas_analyze_sample") + res = duckdb_cursor.execute("select current_setting('pandas_analyze_sample')").fetchall() + assert res == [(1000,)] + @pytest.mark.parametrize('pandas', [NumpyPandas(), ArrowPandas()]) def test_10750(self, duckdb_cursor, pandas): max_row_number = 2000 diff --git a/tools/pythonpkg/tests/fast/pandas/test_pandas_category.py b/tools/pythonpkg/tests/fast/pandas/test_pandas_category.py index 848412a9910..59e28c907bd 100644 --- a/tools/pythonpkg/tests/fast/pandas/test_pandas_category.py +++ b/tools/pythonpkg/tests/fast/pandas/test_pandas_category.py @@ -104,6 +104,18 @@ def test_category_string_uint8(self, duckdb_cursor): category.append(str(i)) check_create_table(category) + def test_empty_categorical(self, duckdb_cursor): + empty_categoric_df = pd.DataFrame({'category': pd.Series(dtype='category')}) + duckdb_cursor.execute("CREATE TABLE test AS SELECT * FROM empty_categoric_df") + res = duckdb_cursor.table('test').fetchall() + assert res == [] + + with pytest.raises(duckdb.ConversionException, match="Could not convert string 'test' to UINT8"): + duckdb_cursor.execute("insert into test VALUES('test')") + duckdb_cursor.execute("insert into test VALUES(NULL)") + res = duckdb_cursor.table('test').fetchall() + assert res == [(None,)] + def test_category_fetch_df_chunk(self, duckdb_cursor): con = duckdb.connect() categories = ['foo', 'bla', None, 'zoo', 'foo', 'foo', None, 'bla'] diff --git a/tools/pythonpkg/tests/fast/test_relation.py b/tools/pythonpkg/tests/fast/test_relation.py index 53e4c75f45d..4d66adf8256 100644 --- a/tools/pythonpkg/tests/fast/test_relation.py +++ b/tools/pythonpkg/tests/fast/test_relation.py @@ -527,10 +527,7 @@ def test_materialized_relation_view(self, duckdb_cursor): duckdb_cursor.sql( """ create table tbl(a varchar); - insert into tbl values ('test'); - SELECT - * - FROM tbl + insert into tbl values ('test') returning * """ ).to_view('vw') res = duckdb_cursor.sql("select * from vw").fetchone() diff --git a/tools/pythonpkg/tests/fast/test_replacement_scan.py b/tools/pythonpkg/tests/fast/test_replacement_scan.py index 6796ac10855..f02db7e0338 100644 --- a/tools/pythonpkg/tests/fast/test_replacement_scan.py +++ b/tools/pythonpkg/tests/fast/test_replacement_scan.py @@ -2,6 +2,7 @@ import os import pytest +pa = pytest.importorskip("pyarrow") pl = pytest.importorskip("polars") pd = pytest.importorskip("pandas") @@ -46,6 +47,22 @@ def fetch_relation(rel): return rel +def from_pandas(): + df = pd.DataFrame({'a': [1, 2, 3]}) + return df + + +def from_arrow(): + schema = pa.schema([('field_1', pa.int64())]) + df = pa.RecordBatchReader.from_batches(schema, [pa.RecordBatch.from_arrays([pa.array([1, 2, 3])], schema=schema)]) + return df + + +def create_relation(conn, query: str) -> duckdb.DuckDBPyRelation: + df = pd.DataFrame({'a': [1, 2, 3]}) + return conn.sql(query) + + class TestReplacementScan(object): def test_csv_replacement(self): con = duckdb.connect() @@ -103,6 +120,17 @@ def test_replacement_scan_pandas_alias(self): df3 = con.query('from df1 join df2 using(i)') assert df3.fetchall() == [(1, 2, 10)] + def test_replacement_scan_after_creation(self, duckdb_cursor): + duckdb_cursor.execute("create table df (a varchar)") + duckdb_cursor.execute("insert into df values (4), (5), (6)") + rel = duckdb_cursor.sql("select * from df") + + duckdb_cursor.execute("drop table df") + df = pd.DataFrame({'b': [1, 2, 3]}) + res = rel.fetchall() + # FIXME: this should error instead, the 'df' table we relied on has been removed and replaced with a replacement scan + assert res == [(1,), (2,), (3,)] + def test_replacement_scan_caching(self, duckdb_cursor): def return_rel(conn): df = pd.DataFrame({'a': [1, 2, 3]}) @@ -110,11 +138,9 @@ def return_rel(conn): return rel rel = return_rel(duckdb_cursor) - # FIXME: this test should fail in the future - # The correct answer here is [1,2,3], as that is the 'df' that was visible during creation of the Relation duckdb_cursor.execute("create table df as select * from unnest([4,5,6])") res = rel.fetchall() - assert res == [(4,), (5,), (6,)] + assert res == [(1,), (2,), (3,)] def test_replacement_scan_fail(self): random_object = "I love salmiak rondos" @@ -125,17 +151,247 @@ def test_replacement_scan_fail(self): ): con.execute("select count(*) from random_object").fetchone() + @pytest.mark.parametrize( + 'df_create', + [ + from_pandas, + from_arrow, + ], + ) + def test_cte(self, duckdb_cursor, df_create): + df = df_create() + rel = duckdb_cursor.sql("with cte as (select * from df) select * from cte") + res = rel.fetchall() + assert res == [(1,), (2,), (3,)] + + df = df_create() + query = """ + WITH cte as (select * from df) + select * from ( + WITH cte as (select * from df) + select * from ( + WITH cte as (select * from df) + select ( + select * from cte + ) from cte + ) + ) + """ + rel = duckdb_cursor.sql(query) + duckdb_cursor.execute("create table df as select * from range(4, 7)") + res = rel.fetchall() + """ + select ( + select * from cte + ) from cte + This will select the first row from the cte, and do this 3 times since we added 'from cte', and cte has 3 tuples + """ + + if df_create == from_arrow: + # Because the RecordBatchReader is destructive, it's empty after the first scan + # But we reference it multiple times, so the subsequent reads have no data to read + assert res == [(None,), (None,), (None,)] + else: + assert res == [(1,), (1,), (1,)] + + def test_cte_with_scalar_subquery(self, duckdb_cursor): + query = """ + WITH cte1 AS ( + select (select * from df) + ) + select * from cte1; + """ + rel = create_relation(duckdb_cursor, query) + res = rel.fetchall() + assert res == [(1,)] + + def test_cte_with_joins(self, duckdb_cursor): + query = """ + WITH cte1 AS ( + SELECT * FROM df + ), + cte2 AS ( + SELECT * FROM df + WHERE a > 1 + ), + cte3 AS ( + SELECT * FROM df + WHERE a < 3 + ) + SELECT * FROM ( + SELECT + cte1.*, + cte2.a AS cte2_a, + subquery.a AS cte3_a + FROM cte1 + JOIN cte2 ON cte1.a = cte2.a + JOIN ( + SELECT + df.*, + cte3.a AS cte3_a + FROM df + JOIN cte3 ON df.a = cte3.a + ) AS subquery ON cte1.a = subquery.a + ) AS main_query + WHERE main_query.a = 2 + """ + rel = create_relation(duckdb_cursor, query) + duckdb_cursor.execute("create table df as select * from range(4, 7)") + res = rel.fetchall() + assert res == [(2, 2, 2)] + + def test_same_name_cte(self, duckdb_cursor): + query = """ + WITH df AS ( + SELECT a+1 FROM df + ) + SELECT * FROM df; + """ + rel = create_relation(duckdb_cursor, query) + res = rel.fetchall() + assert res == [(1,), (2,), (3,)] + + query = """ + WITH RECURSIVE df AS ( + SELECT a+1 FROM df + ) + SELECT * FROM df; + """ + rel = create_relation(duckdb_cursor, query) + res = rel.fetchall() + assert res == [(1,), (2,), (3,)] + + def test_use_with_view(self, duckdb_cursor): + rel = create_relation(duckdb_cursor, "select * from df") + rel.create_view('v1') + + del rel + rel = duckdb_cursor.sql("select * from v1") + res = rel.fetchall() + assert res == [(1,), (2,), (3,)] + duckdb_cursor.execute("drop view v1") + + def create_view_in_func(con): + df = pd.DataFrame({"a": [1, 2, 3]}) + con.execute('CREATE VIEW v1 AS SELECT * FROM df') + + create_view_in_func(duckdb_cursor) + + # FIXME: this should be fixed in the future, likely by unifying the behavior of .sql and .execute + with pytest.raises(duckdb.CatalogException, match='Table with name df does not exist'): + rel = duckdb_cursor.sql("select * from v1") + + def test_recursive_cte(self, duckdb_cursor): + query = """ + WITH RECURSIVE + RecursiveCTE AS ( + SELECT Number from df t(Number) + UNION ALL + SELECT Number + (select a from df offset 2 limit 1) + 1 as new + FROM RecursiveCTE + WHERE new < 10 + ) + select * from RecursiveCTE; + """ + rel = create_relation(duckdb_cursor, query) + res = rel.fetchall() + assert res == [(1,), (2,), (3,), (5,), (6,), (7,), (9,)] + + # RecursiveCTE references another CTE which references the 'df' + query = """ + WITH RECURSIVE + other_cte as ( + select * from df t(c) + ), + RecursiveCTE AS ( + SELECT Number from other_cte t(Number) + UNION ALL + SELECT Number + (select c from other_cte offset 2 limit 1) + 1 as new + FROM RecursiveCTE + WHERE new < 10 + ) + select * from RecursiveCTE; + """ + rel = create_relation(duckdb_cursor, query) + res = rel.fetchall() + assert res == [(1,), (2,), (3,), (5,), (6,), (7,), (9,)] + + def test_multiple_replacements(self, duckdb_cursor): + # Sample data for Employees table + employees_data = [ + {"EmployeeID": 1, "EmployeeName": "Alice", "ManagerID": None}, + {"EmployeeID": 2, "EmployeeName": "Bob", "ManagerID": 1}, + {"EmployeeID": 3, "EmployeeName": "Charlie", "ManagerID": 1}, + {"EmployeeID": 4, "EmployeeName": "David", "ManagerID": 2}, + {"EmployeeID": 5, "EmployeeName": "Eve", "ManagerID": 2}, + ] + + # Convert list of dictionaries to pandas DataFrame + employees_df = pd.DataFrame(employees_data) + # First mention of `employees_df` has an alias, second doesn't + query = """ + SELECT + e1.EmployeeID, + e1.EmployeeName, + employees_df.ManagerID + FROM employees_df e1 + JOIN employees_df ON e1.ManagerID = employees_df.EmployeeID; + """ + rel = duckdb_cursor.sql(query) + res = rel.fetchall() + assert res == [(3, 'Charlie', None), (5, 'Eve', 1.0), (2, 'Bob', None), (4, 'David', 1.0)] + + def test_cte_at_different_levels(self, duckdb_cursor): + query = """ + SELECT * FROM ( + WITH cte1 AS ( + SELECT * FROM df + ) + SELECT + cte1.*, + cte2.a AS cte2_a, + subquery.a AS cte3_a + FROM cte1 + JOIN ( + WITH cte2 AS ( + SELECT * FROM df + WHERE a > 1 + ) + SELECT * FROM cte2 + ) AS cte2 ON cte1.a = cte2.a + JOIN ( + WITH cte3 AS ( + SELECT * FROM df + WHERE a < 3 + ) + SELECT + df.*, + cte3.a AS cte3_a + FROM ( + SELECT * FROM df + ) AS df + JOIN cte3 ON df.a = cte3.a + ) AS subquery ON cte1.a = subquery.a + ) AS main_query + WHERE main_query.a = 2 + """ + rel = create_relation(duckdb_cursor, query) + duckdb_cursor.execute("create table df as select * from range(4, 7)") + res = rel.fetchall() + assert res == [(2, 2, 2)] + def test_replacement_disabled(self): - df = pd.DataFrame({'a': [1, 2, 3]}) # Create regular connection, not disabled con = duckdb.connect() - res = con.sql("select * from df").fetchall() + rel = create_relation(con, "select * from df") + res = rel.fetchall() assert res == [(1,), (2,), (3,)] ## disable external access con.execute("set enable_external_access=false") with pytest.raises(duckdb.CatalogException, match='Table with name df does not exist!'): - res = con.sql("select * from df").fetchall() + rel = create_relation(con, "select * from df") + res = rel.fetchall() with pytest.raises( duckdb.InvalidInputException, match='Cannot change enable_external_access setting while database is running' ): @@ -144,18 +400,20 @@ def test_replacement_disabled(self): # Create connection with external access disabled con = duckdb.connect(config={'enable_external_access': False}) with pytest.raises(duckdb.CatalogException, match='Table with name df does not exist!'): - res = con.sql("select * from df").fetchall() + rel = create_relation(con, "select * from df") + res = rel.fetchall() # Create regular connection, disable inbetween creation and execution con = duckdb.connect() - rel = con.sql("select * from df") + rel = create_relation(con, "select * from df") con.execute("set enable_external_access=false") - with pytest.raises( - duckdb.InvalidInputException, match='Attempting to execute an unsuccessful or closed pending query result' - ): - res = rel.fetchall() + # Since we cache the replacement scans as CTEs, disabling the external access inbetween creation + # and execution has no effect, we might want to change that by keeping track of which CTEs we have added + # and removing them if `enable_external_access` is set + res = rel.fetchall() + assert res == [(1,), (2,), (3,)] def test_replacement_of_cross_connection_relation(self): con1 = duckdb.connect(':memory:') diff --git a/tools/swift/duckdb-swift/README.md b/tools/swift/duckdb-swift/README.md index 32cda63cd4b..a190dfd1730 100644 --- a/tools/swift/duckdb-swift/README.md +++ b/tools/swift/duckdb-swift/README.md @@ -64,7 +64,7 @@ Development is managed through [the main DuckDB repository](https://github.com/d ``` 3. Generate the Unified Build files for the package: ```shell - python3 tools/swift/create-package.py tools/swift + python3 tools/swift/create_package.py tools/swift ``` 4. Open the Xcode workspace at `tools/swift/duckdb-swift/DuckDB.xcworkspace`